adonisjs-pulse 0.0.1

package/build/src/recorders/servers.js

@@ -0,0 +1,133 @@
+import { Recorder } from './recorder.js';
+import { Value } from '../value.js';
+import { execSync } from 'node:child_process';
+import { hostname } from 'node:os';
+export default class Servers extends Recorder {
+    serverName;
+    directories;
+    interval = null;
+    constructor(options = {}) {
+        super(options);
+        this.serverName = options.serverName || hostname();
+        this.directories = options.directories || ['/'];
+    }
+    register() {
+        if (!this.enabled) {
+            return;
+        }
+        this.record();
+        this.interval = setInterval(() => {
+            this.record();
+        }, 15000);
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    record() {
+        if (!this.enabled) {
+            return;
+        }
+        const cpu = this.getCpuUsage();
+        const memory = this.getMemoryUsage();
+        const storage = this.getStorageUsage();
+        this.pulse.set(new Value(Date.now(), 'system', this.serverName, JSON.stringify({
+            name: this.serverName,
+            cpu,
+            memory_used: memory.used,
+            memory_total: memory.total,
+            storage: storage,
+        })));
+    }
+    getCpuUsage() {
+        try {
+            if (process.platform === 'linux') {
+                const output = execSync("grep 'cpu ' /proc/stat").toString();
+                const parts = output.trim().split(/\s+/);
+                const idle = Number.parseInt(parts[4], 10);
+                const total = parts.slice(1).reduce((sum, val) => sum + Number.parseInt(val, 10), 0);
+                return Math.round(((total - idle) / total) * 100);
+            }
+            else if (process.platform === 'darwin') {
+                const output = execSync("top -l 1 | grep 'CPU usage'").toString();
+                const match = output.match(/(\d+\.\d+)%\s+user/);
+                if (match) {
+                    return Math.round(Number.parseFloat(match[1]));
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return 0;
+    }
+    getMemoryUsage() {
+        try {
+            if (process.platform === 'linux') {
+                const output = execSync('free -b').toString();
+                const lines = output.trim().split('\n');
+                const memLine = lines[1].split(/\s+/);
+                return {
+                    total: Number.parseInt(memLine[1], 10),
+                    used: Number.parseInt(memLine[2], 10),
+                };
+            }
+            else if (process.platform === 'darwin') {
+                const pageSize = Number.parseInt(execSync('pagesize').toString().trim(), 10);
+                const vmStat = execSync('vm_stat').toString();
+                const matches = {
+                    free: vmStat.match(/Pages free:\s+(\d+)/),
+                    active: vmStat.match(/Pages active:\s+(\d+)/),
+                    inactive: vmStat.match(/Pages inactive:\s+(\d+)/),
+                    speculative: vmStat.match(/Pages speculative:\s+(\d+)/),
+                    wired: vmStat.match(/Pages wired down:\s+(\d+)/),
+                    compressed: vmStat.match(/Pages occupied by compressor:\s+(\d+)/),
+                };
+                const free = (Number.parseInt(matches.free?.[1] || '0', 10) +
+                    Number.parseInt(matches.speculative?.[1] || '0', 10)) *
+                    pageSize;
+                const used = (Number.parseInt(matches.active?.[1] || '0', 10) +
+                    Number.parseInt(matches.inactive?.[1] || '0', 10) +
+                    Number.parseInt(matches.wired?.[1] || '0', 10) +
+                    Number.parseInt(matches.compressed?.[1] || '0', 10)) *
+                    pageSize;
+                const total = free + used;
+                return { total, used };
+            }
+        }
+        catch {
+            // ignore
+        }
+        return { total: 0, used: 0 };
+    }
+    getStorageUsage() {
+        const storage = [];
+        for (const directory of this.directories) {
+            try {
+                const output = execSync(`df -B1 "${directory}" 2>/dev/null || df -k "${directory}"`).toString();
+                const lines = output.trim().split('\n');
+                const parts = lines[1].split(/\s+/);
+                if (output.includes('-B1')) {
+                    storage.push({
+                        directory,
+                        total: Number.parseInt(parts[1], 10),
+                        used: Number.parseInt(parts[2], 10),
+                    });
+                }
+                else {
+                    storage.push({
+                        directory,
+                        total: Number.parseInt(parts[1], 10) * 1024,
+                        used: Number.parseInt(parts[2], 10) * 1024,
+                    });
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        return storage;
+    }
+}

package/build/src/recorders/slow_queries.d.ts

@@ -0,0 +1,8 @@
+import { Recorder } from './recorder.js';
+export default class SlowQueries extends Recorder {
+    register(): Promise<void>;
+    protected record(payload: {
+        sql: string;
+        duration?: [number, number];
+    }): void;
+}

package/build/src/recorders/slow_queries.js

@@ -0,0 +1,27 @@
+import { Recorder } from './recorder.js';
+import { Entry } from '../entry.js';
+export default class SlowQueries extends Recorder {
+    async register() {
+        if (!this.enabled) {
+            return;
+        }
+        const emitter = await this.app.container.make('emitter');
+        emitter.on('db:query', (payload) => {
+            this.record(payload);
+        });
+    }
+    record(payload) {
+        if (!this.shouldSample()) {
+            return;
+        }
+        const { sql, duration } = payload;
+        if (this.shouldIgnore(sql)) {
+            return;
+        }
+        const time = Math.round(Number(duration?.[1] ?? 0) / 1_000_000);
+        if (time < this.threshold) {
+            return;
+        }
+        this.pulse.record(new Entry(Date.now(), 'slow_query', JSON.stringify([sql]), time).max().count());
+    }
+}

package/build/src/recorders/slow_requests.d.ts

@@ -0,0 +1,11 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import { Recorder } from './recorder.js';
+export default class SlowRequests extends Recorder {
+    register(): Promise<void>;
+    protected record(payload: {
+        ctx: HttpContext;
+        duration: [number, number];
+    }): void;
+    protected resolveHandler(ctx: HttpContext): string;
+    protected recordUser(ctx: HttpContext, time: number): void;
+}

package/build/src/recorders/slow_requests.js

@@ -0,0 +1,80 @@
+import { Recorder } from './recorder.js';
+import { Entry } from '../entry.js';
+import { Value } from '../value.js';
+export default class SlowRequests extends Recorder {
+    async register() {
+        if (!this.enabled) {
+            return;
+        }
+        const emitter = await this.app.container.make('emitter');
+        emitter.on('http:request_completed', (payload) => {
+            this.record(payload);
+        });
+    }
+    record(payload) {
+        const { ctx, duration } = payload;
+        if (!ctx.route) {
+            return;
+        }
+        if (!this.shouldSample()) {
+            return;
+        }
+        if (this.shouldIgnore(ctx.route.pattern)) {
+            return;
+        }
+        const handler = this.resolveHandler(ctx);
+        const time = Math.round(Number(duration?.[1] ?? 0) / 1_000_000);
+        if (time < this.threshold) {
+            return;
+        }
+        this.pulse.record(new Entry(Date.now(), 'slow_request', JSON.stringify([ctx.request.method(), ctx.route.pattern, handler]), time)
+            .max()
+            .count());
+        this.recordUser(ctx, time);
+    }
+    resolveHandler(ctx) {
+        let handler = 'Closure';
+        if (typeof ctx.route.handler === 'string') {
+            handler = ctx.route.handler;
+        }
+        else if (Array.isArray(ctx.route.handler)) {
+            if (ctx.route.handler.length === 1) {
+                handler = ctx.route.handler[0];
+            }
+            else if (ctx.route.handler.length === 2) {
+                handler = `${ctx.route.handler[0]}@${ctx.route.handler[1]}`;
+            }
+        }
+        else if (ctx.route.handler &&
+            'reference' in ctx.route.handler &&
+            'name' in ctx.route.handler) {
+            const routeHandler = ctx.route.handler;
+            if (typeof routeHandler.reference === 'string') {
+                handler = `${routeHandler.reference}`;
+            }
+            else if (Array.isArray(routeHandler.reference)) {
+                let fun = 'unknown';
+                if (routeHandler.reference.length === 1) {
+                    fun = String(routeHandler.reference[0]);
+                }
+                else if (routeHandler.reference.length === 2) {
+                    fun = `${routeHandler.reference[1]}`;
+                }
+                handler = `${routeHandler.name}.${fun}`;
+            }
+        }
+        return handler;
+    }
+    recordUser(ctx, time) {
+        const auth = ctx.auth;
+        if (!auth?.user) {
+            return;
+        }
+        this.pulse.set(new Value(Date.now(), 'user', String(auth.user.id), JSON.stringify({
+            id: auth.user.id,
+            name: auth.user.fullName ?? auth.user.name ?? auth.user.email,
+            email: auth.user.email,
+        })));
+        this.pulse.record(new Entry(Date.now(), 'slow_user_request', String(auth.user.id), time).count());
+    }
+}

package/build/src/storage/database_storage.d.ts

@@ -0,0 +1,20 @@
+import type { Database } from '@adonisjs/lucid/database';
+import type { Entry } from '../entry.js';
+import type { Value } from '../value.js';
+import type { AggregationType, PulseStorage, StoredValue, AggregateResult, AggregateTypesResult, ResolvedPulseConfig } from '../types.js';
+export declare class DatabaseStorage implements PulseStorage {
+    protected db: Database;
+    protected config: ResolvedPulseConfig;
+    constructor(db: Database, config: ResolvedPulseConfig);
+    protected hash(key: string): string;
+    protected bucket(timestamp: number, period: number): number;
+    store(entries: Entry[], values: Value[]): Promise<void>;
+    trim(): Promise<void>;
+    purge(types?: string[]): Promise<void>;
+    values(type: string, keys?: string[]): Promise<StoredValue[]>;
+    aggregate(type: string, aggregates: AggregationType[], interval: number, orderBy?: AggregationType, direction?: 'asc' | 'desc', limit?: number): Promise<Map<string, AggregateResult>>;
+    graph(types: string[], aggregate: AggregationType, interval: number): Promise<Map<number, Map<string, number>>>;
+    protected findPeriod(interval: number): number;
+    aggregateTypes(types: string[], aggregate: AggregationType, interval: number, orderBy?: string, direction?: 'asc' | 'desc', limit?: number): Promise<AggregateTypesResult[]>;
+    aggregateTotal(types: string[], aggregate: AggregationType, interval: number): Promise<Record<string, number>>;
+}

package/build/src/storage/database_storage.js

@@ -0,0 +1,357 @@
+import { createHash } from 'node:crypto';
+export class DatabaseStorage {
+    db;
+    config;
+    constructor(db, config) {
+        this.db = db;
+        this.config = config;
+    }
+    hash(key) {
+        return createHash('sha256').update(key).digest('hex');
+    }
+    bucket(timestamp, period) {
+        return Math.floor(timestamp / 1000 / period) * period;
+    }
+    async store(entries, values) {
+        await this.db.transaction(async (trx) => {
+            if (values.length > 0) {
+                for (const value of values) {
+                    const attrs = value.attributes();
+                    const keyHash = this.hash(attrs.key);
+                    const timestamp = Math.floor(attrs.timestamp / 1000);
+                    const existing = await trx
+                        .from('pulse_values')
+                        .where('type', attrs.type)
+                        .where('key_hash', keyHash)
+                        .first();
+                    if (existing) {
+                        await trx
+                            .from('pulse_values')
+                            .where('type', attrs.type)
+                            .where('key_hash', keyHash)
+                            .update({
+                            timestamp,
+                            value: attrs.value,
+                        });
+                    }
+                    else {
+                        await trx.insertQuery().table('pulse_values').insert({
+                            timestamp,
+                            type: attrs.type,
+                            key: attrs.key,
+                            key_hash: keyHash,
+                            value: attrs.value,
+                        });
+                    }
+                }
+            }
+            const entriesToInsert = [];
+            const aggregates = new Map();
+            for (const entry of entries) {
+                const attrs = entry.attributes();
+                const keyHash = this.hash(attrs.key);
+                if (!entry.isOnlyBuckets()) {
+                    entriesToInsert.push(entry);
+                }
+                for (const aggregate of entry.getAggregations()) {
+                    const periods = [60, 360, 1440, 10080];
+                    for (const period of periods) {
+                        const bucket = this.bucket(attrs.timestamp, period);
+                        const compositeKey = `${bucket}:${period}:${attrs.type}:${aggregate}:${keyHash}`;
+                        const existing = aggregates.get(compositeKey);
+                        const value = attrs.value ?? 0;
+                        if (existing) {
+                            switch (aggregate) {
+                                case 'count':
+                                    existing.count += 1;
+                                    break;
+                                case 'min':
+                                    existing.value = Math.min(existing.value, value);
+                                    break;
+                                case 'max':
+                                    existing.value = Math.max(existing.value, value);
+                                    break;
+                                case 'sum':
+                                case 'avg':
+                                    existing.value += value;
+                                    existing.count += 1;
+                                    break;
+                            }
+                        }
+                        else {
+                            aggregates.set(compositeKey, {
+                                entry,
+                                value: aggregate === 'count' ? 0 : value,
+                                count: 1,
+                            });
+                        }
+                    }
+                }
+            }
+            if (entriesToInsert.length > 0) {
+                const rows = entriesToInsert.map((entry) => {
+                    const attrs = entry.attributes();
+                    return {
+                        timestamp: Math.floor(attrs.timestamp / 1000),
+                        type: attrs.type,
+                        key: attrs.key,
+                        key_hash: this.hash(attrs.key),
+                        value: attrs.value,
+                    };
+                });
+                await trx.insertQuery().table('pulse_entries').multiInsert(rows);
+            }
+            for (const [compositeKey, data] of aggregates) {
+                const [bucket, period, type, aggregate, keyHash] = compositeKey.split(':');
+                const existingAggregate = await trx
+                    .from('pulse_aggregates')
+                    .where('bucket', Number(bucket))
+                    .where('period', Number(period))
+                    .where('type', type)
+                    .where('aggregate', aggregate)
+                    .where('key_hash', keyHash)
+                    .first();
+                if (existingAggregate) {
+                    let newValue;
+                    let newCount = null;
+                    switch (aggregate) {
+                        case 'count':
+                            newValue = Number(existingAggregate.value) + 1;
+                            break;
+                        case 'min':
+                            newValue = Math.min(Number(existingAggregate.value), data.value);
+                            break;
+                        case 'max':
+                            newValue = Math.max(Number(existingAggregate.value), data.value);
+                            break;
+                        case 'sum':
+                            newValue = Number(existingAggregate.value) + data.value;
+                            break;
+                        case 'avg':
+                            newValue = Number(existingAggregate.value) + data.value;
+                            newCount = Number(existingAggregate.count) + data.count;
+                            break;
+                        default:
+                            newValue = data.value;
+                    }
+                    const updateData = { value: newValue };
+                    if (newCount !== null) {
+                        updateData.count = newCount;
+                    }
+                    await trx
+                        .from('pulse_aggregates')
+                        .where('bucket', Number(bucket))
+                        .where('period', Number(period))
+                        .where('type', type)
+                        .where('aggregate', aggregate)
+                        .where('key_hash', keyHash)
+                        .update(updateData);
+                }
+                else {
+                    await trx
+                        .insertQuery()
+                        .table('pulse_aggregates')
+                        .insert({
+                        bucket: Number(bucket),
+                        period: Number(period),
+                        type,
+                        key: data.entry.key,
+                        key_hash: keyHash,
+                        aggregate,
+                        value: aggregate === 'count' ? data.count : data.value,
+                        count: aggregate === 'avg' ? data.count : null,
+                    });
+                }
+            }
+        });
+    }
+    async trim() {
+        const now = Math.floor(Date.now() / 1000);
+        await this.db
+            .from('pulse_entries')
+            .where('timestamp', '<', now - this.config.retain.entries)
+            .delete();
+        await this.db
+            .from('pulse_values')
+            .where('timestamp', '<', now - this.config.retain.values)
+            .delete();
+        const periods = [
+            { period: 60, retain: this.config.retain.aggregates },
+            { period: 360, retain: this.config.retain.aggregates },
+            { period: 1440, retain: this.config.retain.aggregates },
+            { period: 10080, retain: this.config.retain.aggregates },
+        ];
+        for (const { period, retain } of periods) {
+            const oldestBucket = this.bucket((now - retain) * 1000, period);
+            await this.db
+                .from('pulse_aggregates')
+                .where('period', period)
+                .where('bucket', '<', oldestBucket)
+                .delete();
+        }
+    }
+    async purge(types) {
+        const tables = ['pulse_entries', 'pulse_values', 'pulse_aggregates'];
+        for (const table of tables) {
+            if (types && types.length > 0) {
+                await this.db.from(table).whereIn('type', types).delete();
+            }
+            else {
+                await this.db.from(table).delete();
+            }
+        }
+    }
+    async values(type, keys) {
+        const query = this.db.from('pulse_values').where('type', type);
+        if (keys && keys.length > 0) {
+            const hashes = keys.map((k) => this.hash(k));
+            query.whereIn('key_hash', hashes);
+        }
+        return query.select('*');
+    }
+    async aggregate(type, aggregates, interval, orderBy, direction = 'desc', limit) {
+        const now = Math.floor(Date.now() / 1000);
+        const period = this.findPeriod(interval);
+        const oldestBucket = this.bucket((now - interval) * 1000, period);
+        const results = new Map();
+        const rows = await this.db
+            .from('pulse_aggregates')
+            .where('type', type)
+            .where('period', period)
+            .where('bucket', '>=', oldestBucket)
+            .whereIn('aggregate', aggregates)
+            .select('key', 'aggregate', 'value', 'count');
+        for (const row of rows) {
+            const existing = results.get(row.key) || { key: row.key };
+            switch (row.aggregate) {
+                case 'count':
+                    existing.count = (existing.count ?? 0) + Number(row.value);
+                    break;
+                case 'min':
+                    existing.min =
+                        existing.min !== undefined
+                            ? Math.min(existing.min, Number(row.value))
+                            : Number(row.value);
+                    break;
+                case 'max':
+                    existing.max =
+                        existing.max !== undefined
+                            ? Math.max(existing.max, Number(row.value))
+                            : Number(row.value);
+                    break;
+                case 'sum':
+                    existing.sum = (existing.sum ?? 0) + Number(row.value);
+                    break;
+                case 'avg':
+                    const prevTotal = (existing.avg ?? 0) * (existing.count ?? 0);
+                    const newCount = (existing.count ?? 0) + Number(row.count ?? 1);
+                    existing.avg = (prevTotal + Number(row.value)) / newCount;
+                    existing.count = newCount;
+                    break;
+            }
+            results.set(row.key, existing);
+        }
+        if (orderBy && results.size > 0) {
+            const sorted = [...results.entries()].sort((a, b) => {
+                const aVal = a[1][orderBy] ?? 0;
+                const bVal = b[1][orderBy] ?? 0;
+                return direction === 'desc' ? bVal - aVal : aVal - bVal;
+            });
+            if (limit) {
+                return new Map(sorted.slice(0, limit));
+            }
+            return new Map(sorted);
+        }
+        return results;
+    }
+    async graph(types, aggregate, interval) {
+        const now = Math.floor(Date.now() / 1000);
+        const period = this.findPeriod(interval);
+        const oldestBucket = this.bucket((now - interval) * 1000, period);
+        const rows = await this.db
+            .from('pulse_aggregates')
+            .whereIn('type', types)
+            .where('period', period)
+            .where('bucket', '>=', oldestBucket)
+            .where('aggregate', aggregate)
+            .select('bucket', 'type', 'value')
+            .orderBy('bucket', 'asc');
+        const results = new Map();
+        for (const row of rows) {
+            if (!results.has(row.bucket)) {
+                results.set(row.bucket, new Map());
+            }
+            const bucketMap = results.get(row.bucket);
+            bucketMap.set(row.type, (bucketMap.get(row.type) ?? 0) + Number(row.value));
+        }
+        return results;
+    }
+    findPeriod(interval) {
+        const periods = [60, 360, 1440, 10080];
+        for (const period of periods) {
+            if (interval <= period * 60) {
+                return period;
+            }
+        }
+        return periods[periods.length - 1];
+    }
+    async aggregateTypes(types, aggregate, interval, orderBy, direction = 'desc', limit) {
+        const now = Math.floor(Date.now() / 1000);
+        const period = this.findPeriod(interval);
+        const oldestBucket = this.bucket((now - interval) * 1000, period);
+        const rows = await this.db
+            .from('pulse_aggregates')
+            .whereIn('type', types)
+            .where('period', period)
+            .where('bucket', '>=', oldestBucket)
+            .where('aggregate', aggregate)
+            .select('key', 'type', 'value', 'count');
+        const results = new Map();
+        for (const row of rows) {
+            const existing = results.get(row.key) || { key: row.key };
+            const rowType = row.type;
+            const countKey = `${rowType}_count`;
+            if (aggregate === 'avg') {
+                const prevTotal = (existing[rowType] ?? 0) * (existing[countKey] ?? 0);
+                const newCount = (existing[countKey] ?? 0) + Number(row.count ?? 1);
+                existing[rowType] = (prevTotal + Number(row.value)) / newCount;
+                existing[countKey] = newCount;
+            }
+            else {
+                existing[rowType] = (existing[rowType] ?? 0) + Number(row.value);
+            }
+            results.set(row.key, existing);
+        }
+        let sorted = [...results.values()];
+        if (orderBy) {
+            sorted.sort((a, b) => {
+                const aVal = (a[orderBy] ?? 0);
+                const bVal = (b[orderBy] ?? 0);
+                return direction === 'desc' ? bVal - aVal : aVal - bVal;
+            });
+        }
+        if (limit) {
+            sorted = sorted.slice(0, limit);
+        }
+        return sorted;
+    }
+    async aggregateTotal(types, aggregate, interval) {
+        const now = Math.floor(Date.now() / 1000);
+        const period = this.findPeriod(interval);
+        const oldestBucket = this.bucket((now - interval) * 1000, period);
+        const rows = await this.db
+            .from('pulse_aggregates')
+            .whereIn('type', types)
+            .where('period', period)
+            .where('bucket', '>=', oldestBucket)
+            .where('aggregate', aggregate)
+            .select('type')
+            .sum('value as total')
+            .groupBy('type');
+        const results = {};
+        for (const row of rows) {
+            results[row.type] = Number(row.total ?? 0);
+        }
+        return results;
+    }
+}