adonisjs-pulse 0.0.1

package/build/src/livewire/slow_queries.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { lazy, url } from 'adonisjs-livewire';
+import { Card } from './card.js';
+let SlowQueries = class SlowQueries extends Card {
+    orderBy = 'slowest';
+    async render() {
+        const aggregateData = await this.aggregate('slow_query', ['max', 'count'], this.orderBy === 'count' ? 'count' : 'max');
+        const slowQueries = aggregateData
+            .values()
+            .map((row) => {
+            const [sql] = JSON.parse(row.key);
+            return {
+                sql,
+                slowest: row.max,
+                count: row.count,
+            };
+        })
+            .toArray();
+        return await this.view.render('pulse::livewire/slow-queries', {
+            period: this.periodForHumans(),
+            config: { threshold: 1_000 },
+            queries: slowQueries,
+        });
+    }
+};
+__decorate([
+    url('slow-queries')
+], SlowQueries.prototype, "orderBy", void 0);
+SlowQueries = __decorate([
+    lazy()
+], SlowQueries);
+export { SlowQueries };

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

@@ -0,0 +1,5 @@
+import { Card } from './card.js';
+export declare class SlowRequests extends Card {
+    orderBy: string;
+    render(): Promise<string>;
+}

package/build/src/livewire/slow_requests.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { lazy, url } from 'adonisjs-livewire';
+import { Card } from './card.js';
+let SlowRequests = class SlowRequests extends Card {
+    orderBy = 'slowest';
+    async render() {
+        const aggregateData = await this.aggregate('slow_request', ['max', 'count'], this.orderBy === 'count' ? 'count' : 'max');
+        const slowRequests = Array.from(aggregateData.entries()).map(([key, row]) => {
+            const [method, uri, action] = JSON.parse(key);
+            return {
+                method,
+                uri,
+                action,
+                slowest: row.max ?? 0,
+                count: row.count ?? 0,
+                threshold: 1_000,
+            };
+        });
+        return await this.view.render('pulse::livewire/slow-requests', {
+            period: this.periodForHumans(),
+            config: { threshold: 1_000 },
+            requests: slowRequests,
+        });
+    }
+};
+__decorate([
+    url('slow-requests')
+], SlowRequests.prototype, "orderBy", void 0);
+SlowRequests = __decorate([
+    lazy()
+], SlowRequests);
+export { SlowRequests };

package/build/src/pulse.d.ts

@@ -0,0 +1,44 @@
+import type { Database } from '@adonisjs/lucid/database';
+import type { ApplicationService } from '@adonisjs/core/types';
+import { Entry } from './entry.js';
+import { Value } from './value.js';
+import type { AggregationType, PulseConfig, PulseStorage, RecordCallback, AggregateResult, AggregateTypesResult, StoredValue, ResolvedPulseConfig, RecorderEntry } from './types.js';
+import type { Recorder } from './recorders/recorder.js';
+export declare class Pulse {
+    protected db: Database;
+    protected entries: Entry[];
+    protected values: Value[];
+    protected lazy: RecordCallback[];
+    protected storage: PulseStorage | null;
+    protected config: ResolvedPulseConfig;
+    protected ingesting: boolean;
+    protected ingestTimer: ReturnType<typeof setInterval> | null;
+    protected recorders: Recorder[];
+    constructor(db: Database, config?: Partial<PulseConfig>);
+    get enabled(): boolean;
+    enable(): this;
+    disable(): this;
+    registerRecorders(app: ApplicationService): Promise<void>;
+    protected registerRecorder(app: ApplicationService, entry: RecorderEntry): Promise<void>;
+    record(entry: Entry): this;
+    set(value: Value): this;
+    setLazy(type: string, key: string, callback: () => string | Promise<string>): this;
+    recordLazy(callback: RecordCallback): this;
+    ingest(): Promise<void>;
+    protected shouldTrim(): boolean;
+    trim(): Promise<void>;
+    purge(types?: string[]): Promise<void>;
+    getValues(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>>>;
+    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>>;
+    startIngesting(): this;
+    stopIngesting(): this;
+    flush(): Promise<void>;
+    getConfig(): ResolvedPulseConfig;
+    getRecorders(): Recorder[];
+    pendingEntries(): number;
+    pendingValues(): number;
+    pendingLazy(): number;
+}

package/build/src/pulse.js

@@ -0,0 +1,224 @@
+import { Entry } from './entry.js';
+import { Value } from './value.js';
+import { DatabaseStorage } from './storage/database_storage.js';
+function resolveConfig(config) {
+    return {
+        enabled: config.enabled ?? true,
+        ingestInterval: config.ingest?.interval ?? 5000,
+        trimLotteryChance: [config.ingest?.lottery?.chance ?? 1, config.ingest?.lottery?.outOf ?? 1000],
+        connection: config.storage?.connection,
+        retain: {
+            entries: 604800,
+            values: 604800,
+            aggregates: 7776000,
+        },
+        recorders: config.recorders ?? [],
+    };
+}
+export class Pulse {
+    db;
+    entries = [];
+    values = [];
+    lazy = [];
+    storage = null;
+    config;
+    ingesting = false;
+    ingestTimer = null;
+    recorders = [];
+    constructor(db, config = {}) {
+        this.db = db;
+        this.config = resolveConfig(config);
+        this.storage = new DatabaseStorage(db, this.config);
+    }
+    get enabled() {
+        return this.config.enabled;
+    }
+    enable() {
+        this.config.enabled = true;
+        return this;
+    }
+    disable() {
+        this.config.enabled = false;
+        return this;
+    }
+    async registerRecorders(app) {
+        for (const entry of this.config.recorders) {
+            await this.registerRecorder(app, entry);
+        }
+    }
+    async registerRecorder(app, entry) {
+        try {
+            const { recorder: lazyRecorder, ...options } = entry;
+            const module = await lazyRecorder();
+            const RecorderClass = module.default;
+            const recorder = new RecorderClass(options);
+            recorder.setApp(app).setPulse(this);
+            await recorder.register();
+            this.recorders.push(recorder);
+        }
+        catch (error) {
+            console.error('Failed to register recorder:', error);
+        }
+    }
+    record(entry) {
+        if (!this.config.enabled) {
+            return this;
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    set(value) {
+        if (!this.config.enabled) {
+            return this;
+        }
+        this.values.push(value);
+        return this;
+    }
+    setLazy(type, key, callback) {
+        if (!this.config.enabled) {
+            return this;
+        }
+        this.lazy.push(async () => {
+            const value = await callback();
+            return new Value(Date.now(), type, key, value);
+        });
+        return this;
+    }
+    recordLazy(callback) {
+        if (!this.config.enabled) {
+            return this;
+        }
+        this.lazy.push(callback);
+        return this;
+    }
+    async ingest() {
+        if (!this.config.enabled || !this.storage || this.ingesting) {
+            return;
+        }
+        this.ingesting = true;
+        try {
+            const entries = [...this.entries];
+            const values = [...this.values];
+            const lazyCallbacks = [...this.lazy];
+            this.entries = [];
+            this.values = [];
+            this.lazy = [];
+            for (const callback of lazyCallbacks) {
+                try {
+                    const result = await callback();
+                    if (result === null) {
+                        continue;
+                    }
+                    if (Array.isArray(result)) {
+                        for (const item of result) {
+                            if (item instanceof Entry) {
+                                entries.push(item);
+                            }
+                            else if (item instanceof Value) {
+                                values.push(item);
+                            }
+                        }
+                    }
+                    else if (result instanceof Entry) {
+                        entries.push(result);
+                    }
+                    else if (result instanceof Value) {
+                        values.push(result);
+                    }
+                }
+                catch {
+                    // Ignore errors in lazy callbacks
+                }
+            }
+            if (entries.length > 0 || values.length > 0) {
+                await this.storage.store(entries, values);
+            }
+            if (this.shouldTrim()) {
+                await this.trim();
+            }
+        }
+        finally {
+            this.ingesting = false;
+        }
+    }
+    shouldTrim() {
+        const [chance, outOf] = this.config.trimLotteryChance;
+        return Math.random() * outOf < chance;
+    }
+    async trim() {
+        if (!this.storage) {
+            return;
+        }
+        await this.storage.trim();
+    }
+    async purge(types) {
+        if (!this.storage) {
+            return;
+        }
+        await this.storage.purge(types);
+    }
+    async getValues(type, keys) {
+        if (!this.storage) {
+            return [];
+        }
+        return this.storage.values(type, keys);
+    }
+    async aggregate(type, aggregates, interval, orderBy, direction = 'desc', limit) {
+        if (!this.storage) {
+            return new Map();
+        }
+        return this.storage.aggregate(type, aggregates, interval, orderBy, direction, limit);
+    }
+    async graph(types, aggregate, interval) {
+        if (!this.storage) {
+            return new Map();
+        }
+        return this.storage.graph(types, aggregate, interval);
+    }
+    async aggregateTypes(types, aggregate, interval, orderBy, direction = 'desc', limit) {
+        if (!this.storage) {
+            return [];
+        }
+        return this.storage.aggregateTypes(types, aggregate, interval, orderBy, direction, limit);
+    }
+    async aggregateTotal(types, aggregate, interval) {
+        if (!this.storage) {
+            return {};
+        }
+        return this.storage.aggregateTotal(types, aggregate, interval);
+    }
+    startIngesting() {
+        if (this.ingestTimer) {
+            return this;
+        }
+        this.ingestTimer = setInterval(() => {
+            this.ingest().catch(() => { });
+        }, this.config.ingestInterval);
+        return this;
+    }
+    stopIngesting() {
+        if (this.ingestTimer) {
+            clearInterval(this.ingestTimer);
+            this.ingestTimer = null;
+        }
+        return this;
+    }
+    async flush() {
+        await this.ingest();
+    }
+    getConfig() {
+        return this.config;
+    }
+    getRecorders() {
+        return this.recorders;
+    }
+    pendingEntries() {
+        return this.entries.length;
+    }
+    pendingValues() {
+        return this.values.length;
+    }
+    pendingLazy() {
+        return this.lazy.length;
+    }
+}

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

@@ -0,0 +1,34 @@
+import { Recorder } from './recorder.js';
+interface CacheHitEvent {
+    key: string;
+    value: any;
+    store: string;
+    layer: 'l1' | 'l2';
+    graced: boolean;
+}
+interface CacheMissEvent {
+    key: string;
+    store: string;
+}
+interface CacheWrittenEvent {
+    key: string;
+    value: any;
+    store: string;
+}
+interface CacheDeletedEvent {
+    key: string;
+    store: string;
+}
+interface CacheClearedEvent {
+    store: string;
+}
+export default class CacheInteractions extends Recorder {
+    register(): Promise<void>;
+    protected recordHit(payload: CacheHitEvent): void;
+    protected recordMiss(payload: CacheMissEvent): void;
+    protected recordWritten(payload: CacheWrittenEvent): void;
+    protected recordDeleted(payload: CacheDeletedEvent): void;
+    protected recordCleared(payload: CacheClearedEvent): void;
+    protected group(key: string): string;
+}
+export {};

package/build/src/recorders/cache_interactions.js

@@ -0,0 +1,80 @@
+import { Recorder } from './recorder.js';
+import { Entry } from '../entry.js';
+export default class CacheInteractions extends Recorder {
+    async register() {
+        if (!this.enabled) {
+            return;
+        }
+        if (!this.app.container.hasBinding('cache.manager')) {
+            return;
+        }
+        const emitter = await this.app.container.make('emitter');
+        emitter.on('cache:hit', (payload) => {
+            this.recordHit(payload);
+        });
+        emitter.on('cache:miss', (payload) => {
+            this.recordMiss(payload);
+        });
+        emitter.on('cache:written', (payload) => {
+            this.recordWritten(payload);
+        });
+        emitter.on('cache:deleted', (payload) => {
+            this.recordDeleted(payload);
+        });
+        emitter.on('cache:cleared', (payload) => {
+            this.recordCleared(payload);
+        });
+    }
+    recordHit(payload) {
+        if (!this.shouldSample()) {
+            return;
+        }
+        if (this.shouldIgnore(payload.key)) {
+            return;
+        }
+        this.pulse.record(new Entry(Date.now(), 'cache_hit', this.group(payload.key)).count());
+    }
+    recordMiss(payload) {
+        if (!this.shouldSample()) {
+            return;
+        }
+        if (this.shouldIgnore(payload.key)) {
+            return;
+        }
+        this.pulse.record(new Entry(Date.now(), 'cache_miss', this.group(payload.key)).count());
+    }
+    recordWritten(payload) {
+        if (!this.shouldSample()) {
+            return;
+        }
+        if (this.shouldIgnore(payload.key)) {
+            return;
+        }
+        this.pulse.record(new Entry(Date.now(), 'cache_write', this.group(payload.key)).count());
+    }
+    recordDeleted(payload) {
+        if (!this.shouldSample()) {
+            return;
+        }
+        if (this.shouldIgnore(payload.key)) {
+            return;
+        }
+        this.pulse.record(new Entry(Date.now(), 'cache_delete', this.group(payload.key)).count());
+    }
+    recordCleared(payload) {
+        if (!this.shouldSample()) {
+            return;
+        }
+        this.pulse.record(new Entry(Date.now(), 'cache_clear', payload.store).count());
+    }
+    group(key) {
+        const groups = this.options.groups ?? {};
+        for (const [pattern, replacement] of Object.entries(groups)) {
+            const regex = new RegExp(pattern.slice(1, -1));
+            if (regex.test(key)) {
+                return key.replace(regex, replacement);
+            }
+        }
+        return key;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import { Recorder } from './recorder.js';
+export default class Exceptions extends Recorder {
+    register(): Promise<void>;
+    protected record(error: any, ctx: HttpContext): void;
+    protected getLocation(error: Error): string;
+    recordException(error: Error, ctx?: HttpContext): void;
+}

package/build/src/recorders/exceptions.js

@@ -0,0 +1,81 @@
+import { ExceptionHandler } from '@adonisjs/core/http';
+import { Recorder } from './recorder.js';
+import { Entry } from '../entry.js';
+import { ReflectionClass } from 'unreflect';
+export default class Exceptions extends Recorder {
+    async register() {
+        if (!this.enabled) {
+            return;
+        }
+        const server = await this.app.container.make('server');
+        const record = (error, ctx) => {
+            this.record(error, ctx);
+        };
+        const reflected = new ReflectionClass(server);
+        const resolvedErrorHandler = await reflected.getPropertyValue('#resolvedErrorHandler');
+        reflected.setProperty('#resolvedErrorHandler', await this.app.container.make(class extends ExceptionHandler {
+            async handle(error, ctx) {
+                record(error, ctx);
+                return resolvedErrorHandler.handle(error, ctx);
+            }
+            async report(error, ctx) {
+                return resolvedErrorHandler.report(error, ctx);
+            }
+        }));
+    }
+    record(error, ctx) {
+        if (!this.shouldSample()) {
+            return;
+        }
+        const name = error.name || error.constructor?.name || 'Error';
+        const message = error.message || '';
+        const className = `${name}: ${message}`;
+        if (this.shouldIgnore(className)) {
+            return;
+        }
+        const location = this.getLocation(error);
+        this.pulse.record(new Entry(Date.now(), 'exception', JSON.stringify([className, location]), 1).count());
+        const auth = ctx.auth;
+        if (auth?.user) {
+            this.pulse.record(new Entry(Date.now(), 'user_exception', String(auth.user.id), 1).count());
+        }
+    }
+    getLocation(error) {
+        if (!error.stack) {
+            return 'unknown';
+        }
+        const lines = error.stack.split('\n');
+        for (const line of lines) {
+            const match = line.match(/at\s+(?:.*?\s+)?\(?(.+?):(\d+):(\d+)\)?/);
+            if (match) {
+                const [, file, lineNum, column] = match;
+                if (!file.includes('node_modules')) {
+                    return `${file}:${lineNum}:${column}`;
+                }
+            }
+        }
+        return 'unknown';
+    }
+    recordException(error, ctx) {
+        if (!this.enabled) {
+            return;
+        }
+        if (!this.shouldSample()) {
+            return;
+        }
+        const name = error.name || error.constructor?.name || 'Error';
+        const message = error.message || '';
+        const className = `${name}: ${message}`;
+        if (this.shouldIgnore(className)) {
+            return;
+        }
+        const location = this.getLocation(error);
+        this.pulse.record(new Entry(Date.now(), 'exception', JSON.stringify([className, location]), 1).count());
+        if (ctx) {
+            const auth = ctx.auth;
+            if (auth?.user) {
+                this.pulse.record(new Entry(Date.now(), 'user_exception', String(auth.user.id), 1).count());
+            }
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+export { Recorder } from './recorder.js';
+export type { RecorderOptions } from './recorder.js';
+export { default as SlowQueries } from './slow_queries.js';
+export { default as SlowRequests } from './slow_requests.js';
+export { default as Exceptions } from './exceptions.js';
+export { default as Servers } from './servers.js';
+export { default as CacheInteractions } from './cache_interactions.js';

package/build/src/recorders/index.js

@@ -0,0 +1,6 @@
+export { Recorder } from './recorder.js';
+export { default as SlowQueries } from './slow_queries.js';
+export { default as SlowRequests } from './slow_requests.js';
+export { default as Exceptions } from './exceptions.js';
+export { default as Servers } from './servers.js';
+export { default as CacheInteractions } from './cache_interactions.js';

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

@@ -0,0 +1,24 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { Pulse } from '../pulse.js';
+export interface RecorderOptions {
+    enabled?: boolean;
+    sampleRate?: number;
+    threshold?: number;
+    ignore?: string[];
+    [key: string]: any;
+}
+export declare abstract class Recorder {
+    protected options: RecorderOptions;
+    protected pulse: Pulse;
+    protected app: ApplicationService;
+    constructor(options?: RecorderOptions);
+    get enabled(): boolean;
+    get sampleRate(): number;
+    get threshold(): number;
+    get ignore(): string[];
+    setApp(app: ApplicationService): this;
+    setPulse(pulse: Pulse): this;
+    abstract register(): void | Promise<void>;
+    protected shouldSample(): boolean;
+    protected shouldIgnore(value: string): boolean;
+}

package/build/src/recorders/recorder.js

@@ -0,0 +1,45 @@
+export class Recorder {
+    options;
+    pulse;
+    app;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    get enabled() {
+        return this.options.enabled ?? true;
+    }
+    get sampleRate() {
+        return this.options.sampleRate ?? 1;
+    }
+    get threshold() {
+        return this.options.threshold ?? 0;
+    }
+    get ignore() {
+        return this.options.ignore ?? [];
+    }
+    setApp(app) {
+        this.app = app;
+        return this;
+    }
+    setPulse(pulse) {
+        this.pulse = pulse;
+        return this;
+    }
+    shouldSample() {
+        return Math.random() <= this.sampleRate;
+    }
+    shouldIgnore(value) {
+        for (const pattern of this.ignore) {
+            if (pattern.startsWith('/') && pattern.endsWith('/')) {
+                const regex = new RegExp(pattern.slice(1, -1));
+                if (regex.test(value)) {
+                    return true;
+                }
+            }
+            else if (value.includes(pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { Recorder, RecorderOptions } from './recorder.js';
+export interface ServersOptions extends RecorderOptions {
+    serverName?: string;
+    directories?: string[];
+}
+export default class Servers extends Recorder {
+    protected serverName: string;
+    protected directories: string[];
+    protected interval: ReturnType<typeof setInterval> | null;
+    constructor(options?: ServersOptions);
+    register(): void;
+    stop(): void;
+    record(): void;
+    protected getCpuUsage(): number;
+    protected getMemoryUsage(): {
+        used: number;
+        total: number;
+    };
+    protected getStorageUsage(): {
+        directory: string;
+        used: number;
+        total: number;
+    }[];
+}