adonisjs-server-stats 1.18.0 → 1.18.1

package/dist/src/log_stream/log_stream_service.d.ts

@@ -3,6 +3,7 @@ export declare function parseAndEnrich(line: string): Record<string, unknown> |
 export declare class LogStreamService {
     private recentEntries;
     private static readonly MAX_RECENT_ENTRIES;
+    private static readonly MAX_POLL_BYTES;
     private lastSize;
     private intervalId;
     private logPath;
@@ -16,8 +17,12 @@ export declare class LogStreamService {
      * in real-time without file polling.
      */
     ingest(entry: Record<string, unknown>): void;
+    /** Record a timestamp, capping the array to prevent unbounded growth under high log volume. */
+    private pushRecent;
     getLogStats(): LogStats;
     start(): Promise<void>;
     stop(): void;
+    /** Reset the once-per-streak failure flag after a fully successful poll. */
+    private markPollHealthy;
     private pollNewEntries;
 }

package/dist/src/log_stream/log_stream_service.js

@@ -27,6 +27,7 @@ export function parseAndEnrich(line) {
 export class LogStreamService {
     recentEntries = [];
     static MAX_RECENT_ENTRIES = 10_000;
+    static MAX_POLL_BYTES = 4 * 1024 * 1024;
     lastSize = 0;
     intervalId = null;
     logPath;
@@ -44,12 +45,15 @@ export class LogStreamService {
      */
     ingest(entry) {
         const level = typeof entry.level === 'number' ? entry.level : 30;
-        // Cap the array to prevent unbounded growth under high log volume
+        this.pushRecent(Date.now(), level);
+        this.onEntry?.(entry);
+    }
+    /** Record a timestamp, capping the array to prevent unbounded growth under high log volume. */
+    pushRecent(time, level) {
         if (this.recentEntries.length >= LogStreamService.MAX_RECENT_ENTRIES) {
             this.recentEntries.splice(0, Math.floor(LogStreamService.MAX_RECENT_ENTRIES / 4));
         }
-        this.recentEntries.push({ time: Date.now(), level });
-        this.onEntry?.(entry);
+        this.recentEntries.push({ time, level });
     }
     getLogStats() {
         const now = Date.now();
@@ -102,36 +106,57 @@ export class LogStreamService {
             this.intervalId = null;
         }
     }
+    /** Reset the once-per-streak failure flag after a fully successful poll. */
+    markPollHealthy() {
+        if (this.warnedPollFailure) {
+            this.warnedPollFailure = false;
+            log.info('log stream: log file is readable again — resuming');
+        }
+    }
     async pollNewEntries() {
         if (!this.logPath)
             return;
         try {
-            this.warnedPollFailure = false;
             const stats = await stat(this.logPath);
             // File was truncated/rotated — reset
             if (stats.size < this.lastSize) {
                 this.lastSize = 0;
             }
-            if (stats.size <= this.lastSize)
+            if (stats.size <= this.lastSize) {
+                this.markPollHealthy();
                 return;
-            const newBytes = stats.size - this.lastSize;
+            }
+            // Cap each read so a rotation reset or burst can never allocate the
+            // whole backlog in one buffer; skip ahead and read only the tail.
+            // A partial first line after skipping fails JSON.parse and is dropped.
+            const readFrom = Math.max(this.lastSize, stats.size - LogStreamService.MAX_POLL_BYTES);
+            const newBytes = stats.size - readFrom;
             const buffer = Buffer.alloc(newBytes);
             const fd = await open(this.logPath, 'r');
-            await fd.read(buffer, 0, newBytes, this.lastSize).finally(() => fd.close());
+            await fd.read(buffer, 0, newBytes, readFrom).finally(() => fd.close());
             this.lastSize = stats.size;
+            this.markPollHealthy();
             for (const line of buffer.toString('utf-8').trim().split('\n')) {
                 const entry = parseAndEnrich(line);
                 if (entry) {
                     const level = typeof entry.level === 'number' ? entry.level : 30;
                     const time = typeof entry.time === 'number' ? entry.time : Date.now();
-                    this.recentEntries.push({ time, level });
+                    this.pushRecent(time, level);
                     this.onEntry?.(entry);
                 }
             }
         }
         catch (err) {
-            if (!this.warnedPollFailure) {
-                this.warnedPollFailure = true;
+            if (this.warnedPollFailure)
+                return;
+            this.warnedPollFailure = true;
+            // A missing file is a normal state for the fallback poller — the file
+            // appears once the app writes its first log line. Anything else
+            // (permissions, a directory in the way) deserves a real warning.
+            if (err?.code === 'ENOENT') {
+                log.info('log stream: log file not found (will keep watching) — ' + this.logPath);
+            }
+            else {
                 log.warn('log stream: cannot read log file — ' + err?.message);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adonisjs-server-stats",
-  "version": "1.18.0",
+  "version": "1.18.1",
   "description": "Real-time server monitoring for AdonisJS v6 applications",
   "keywords": [
     "adonisjs",