adonisjs-server-stats 1.18.0 → 1.18.2

package/README.md

@@ -412,7 +412,7 @@ export default defineConfig({
 
 ## Production
 
-By default this package does **nothing** when `NODE_ENV=production` -- no routes are registered and neither the debug nor the dashboard store is built. The metrics engine still runs, so `onStats`, Prometheus, and Transmit broadcasting keep working; there is simply no HTTP surface.
+By default this package does **nothing** when `NODE_ENV=production` -- no routes are registered and neither the debug nor the dashboard store is built. The metrics engine still runs, so `onStats`, Prometheus, and Transmit broadcasting keep working; there is simply no HTTP surface. The `@serverStats()` Edge tag stays registered and renders nothing, so it can live in your layout unconditionally.
 
 Set `production.enabled` to lift that:
 

package/dist/src/edge/plugin.d.ts

@@ -31,6 +31,15 @@ interface EdgeToken {
         };
     };
 }
+/**
+ * Edge plugin that registers `@serverStats()` as a tag that renders nothing.
+ *
+ * Edge prints an unregistered `@tag()` line into the page verbatim, so a layout
+ * that keeps `@serverStats()` in place must still find a tag under that name
+ * when the stats bar is off (production without `production.enabled`, routes
+ * refused by the fail-closed guard). This one reads no assets and emits nothing.
+ */
+export declare function edgePluginServerStatsInert(): (edge: EdgeEngine) => void;
 /**
  * Edge plugin that registers the `@serverStats()` tag.
  */

package/dist/src/edge/plugin.js

@@ -59,6 +59,24 @@ function buildTemplateState(config, clientDir) {
     }
     return state;
 }
+/**
+ * Edge plugin that registers `@serverStats()` as a tag that renders nothing.
+ *
+ * Edge prints an unregistered `@tag()` line into the page verbatim, so a layout
+ * that keeps `@serverStats()` in place must still find a tag under that name
+ * when the stats bar is off (production without `production.enabled`, routes
+ * refused by the fail-closed guard). This one reads no assets and emits nothing.
+ */
+export function edgePluginServerStatsInert() {
+    return (edge) => {
+        edge.registerTag({
+            tagName: 'serverStats',
+            block: false,
+            seekable: true,
+            compile() { },
+        });
+    };
+}
 /**
  * Edge plugin that registers the `@serverStats()` tag.
  */

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/dist/src/provider/provider_helpers_extra.d.ts

@@ -33,8 +33,14 @@ export declare function setupLogStreamBroadcast(transmit: {
 }, channelName: string, pinoHookActive: boolean, makePath: (...parts: string[]) => string): LogStreamService | null;
 /** Check if dashboard dependencies are available. Returns true if available, false if missing. */
 export declare function checkDashboardDepsHelper(config: ResolvedServerStatsConfig, app: ApplicationService): Promise<boolean>;
-/** Register the Edge.js plugin if Edge is available. Returns true if registered. */
-export declare function registerEdgePluginHelper(app: ApplicationService, config: ResolvedServerStatsConfig): Promise<boolean>;
+/**
+ * Register the `@serverStats()` Edge tag if Edge is available.
+ *
+ * The tag is always registered so the layout never prints it as text. With
+ * `renderBar` it renders the stats bar; without it the tag compiles to nothing.
+ * Returns true only when the bar will render.
+ */
+export declare function registerEdgePluginHelper(app: ApplicationService, config: ResolvedServerStatsConfig, renderBar: boolean): Promise<boolean>;
 /** Set up the publisher-only email bridge for non-web environments. */
 export declare function setupNonWebBridgeHelper(emitter: unknown, channel: string): Promise<void>;
 interface StatsIntervalResult {

package/dist/src/provider/provider_helpers_extra.js

@@ -138,16 +138,22 @@ export async function checkDashboardDepsHelper(config, app) {
     return false;
 }
 // ── registerEdgePluginHelper ────────────────────────────────────
-/** Register the Edge.js plugin if Edge is available. Returns true if registered. */
-export async function registerEdgePluginHelper(app, config) {
+/**
+ * Register the `@serverStats()` Edge tag if Edge is available.
+ *
+ * The tag is always registered so the layout never prints it as text. With
+ * `renderBar` it renders the stats bar; without it the tag compiles to nothing.
+ * Returns true only when the bar will render.
+ */
+export async function registerEdgePluginHelper(app, config, renderBar) {
     if (!app.usingEdgeJS)
         return false;
     try {
         const { appImport } = await import('../utils/app_import.js');
         const edge = await appImport('edge.js');
-        const { edgePluginServerStats } = await import('../edge/plugin.js');
-        edge.default.use(edgePluginServerStats(config));
-        return true;
+        const { edgePluginServerStats, edgePluginServerStatsInert } = await import('../edge/plugin.js');
+        edge.default.use(renderBar ? edgePluginServerStats(config) : edgePluginServerStatsInert());
+        return renderBar;
     }
     catch (err) {
         log.warn('could not register Edge plugin: ' + err?.message);

package/dist/src/provider/server_stats_provider.js

@@ -73,14 +73,14 @@ export default class ServerStatsProvider {
         if (config.shouldShow)
             setShouldShow(config.shouldShow);
         const routesRegistered = await this.registerRoutes(config);
-        // Only register the Edge tag when the routes it polls actually exist —
-        // not merely when the environment allows them. The fail-closed guard in
+        // The bar renders only when the routes it polls actually exist — not
+        // merely when the environment allows them. The fail-closed guard in
         // registerAllRoutes can refuse registration (no authorize callback), and
         // rendering the bar then would advertise endpoints that 404 — or, in
         // production, hand every anonymous visitor a pointer at the stats API.
-        this.edgePluginActive = routesRegistered
-            ? await registerEdgePluginHelper(this.app, config)
-            : false;
+        // The tag itself is registered either way: Edge prints an unregistered
+        // `@serverStats()` into the page as literal text.
+        this.edgePluginActive = await registerEdgePluginHelper(this.app, config, routesRegistered);
     }
     /**
      * Whether this package should do anything in the current environment.

package/package.json

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