jinaga-server 3.7.5 → 3.8.0

package/src/http/router.ts

@@ -41,6 +41,13 @@ import { outputReadResultsStreaming } from "./output-formatters";
 import { arrayToResultStream, ResultStream } from "./result-stream";
 import { Stream } from "./stream";
 
+// A streaming response reports itself twice: one line when the stream opens
+// and one when it ends, carrying the messages sent, how long it lasted, and
+// what ended it. Issue #192: the per-message and per-lifecycle-step lines this
+// replaces made the log grow with traffic rather than with the number of events
+// worth knowing about, and `STREAM DONE`'s message count already said what the
+// per-message lines said one at a time. A plain GET says nothing at all, since
+// Trace.dependency already records it. Failures still log.
 function getOrStream<U>(
     getMethod: ((req: RequestUser, params: { [key: string]: string }, query: qs.ParsedQs) => Promise<U | null>),
     streamMethod: ((req: RequestUser, params: { [key: string]: string }, query: qs.ParsedQs) => Promise<Stream<U> | null>)
@@ -49,75 +56,68 @@ function getOrStream<U>(
         const connectionId = Math.random().toString(36).substring(2, 10);
         const user = <RequestUser>(req as any).user;
         const accept = req.headers["accept"];
-        
-        console.log(`[HttpConnection:${connectionId}] New request - User: ${user?.id || 'anonymous'}, Accept: ${accept}, URL: ${req.url}`);
-        
+
         if (accept && accept.indexOf("application/x-jinaga-feed-stream") >= 0) {
-            console.log(`[HttpConnection:${connectionId}] STREAMING request detected`);
-            
             streamMethod(user, req.params, req.query)
                 .then(response => {
                     if (!response) {
-                        console.log(`[HttpConnection:${connectionId}] Stream method returned null - sending 404`);
                         sendRouteMiss(res);
                         next();
                     }
                     else {
-                        console.log(`[HttpConnection:${connectionId}] Setting up streaming response`);
-                        
                         res.type("application/x-jinaga-feed-stream");
                         res.set("Connection", "keep-alive");
                         res.set("Cache-Control", "no-cache");
                         res.set("Access-Control-Allow-Origin", "*");
                         res.flushHeaders();
-                        
-                        console.log(`[HttpConnection:${connectionId}] Headers flushed - setting up event handlers`);
-                        
+
+                        const openedAt = Date.now();
+                        console.log(`[HttpConnection:${connectionId}] Stream opened - User: ${user?.id || 'anonymous'}, URL: ${req.url}`);
+
                         let clientDisconnected = false;
-                        let timeoutTriggered = false;
                         let streamClosed = false;
-                        
+                        // What closed the stream from outside, where something
+                        // other than the feed itself closed it. One value
+                        // rather than a flag per cause, because a stream ends
+                        // exactly once and only the first cause is the reason.
+                        let closedBy: "client disconnect" | "timeout" | null = null;
+
                         // Client disconnect handler
                         req.on("close", () => {
-                            console.log(`[HttpConnection:${connectionId}] CLIENT DISCONNECTED`);
                             clientDisconnected = true;
                             if (!streamClosed) {
-                                console.log(`[HttpConnection:${connectionId}] Closing stream due to client disconnect`);
-                                response.close();
+                                closedBy = "client disconnect";
                                 streamClosed = true;
+                                response.close();
                             }
                         });
-                        
+
                         // Timeout handler
                         const timeout = setTimeout(() => {
-                            console.log(`[HttpConnection:${connectionId}] TIMEOUT TRIGGERED (5 minutes)`);
-                            timeoutTriggered = true;
                             if (!streamClosed) {
-                                console.log(`[HttpConnection:${connectionId}] Closing stream due to timeout`);
-                                response.close();
+                                closedBy = "timeout";
                                 streamClosed = true;
+                                response.close();
                             }
                         }, 5 * 60 * 1000);
-                        
+
                         let messageCount = 0;
-                        
+
                         response
                             .next(data => {
                                 messageCount++;
                                 const writeStart = Date.now();
-                                
+
                                 if (clientDisconnected) {
                                     console.warn(`[HttpConnection:${connectionId}] Attempted to write to disconnected client - Message #${messageCount}`);
                                     return;
                                 }
-                                
+
                                 try {
                                     const jsonData = JSON.stringify(data) + "\n\n";
                                     res.write(jsonData);
                                     const writeDuration = Date.now() - writeStart;
-                                    
-                                    console.log(`[HttpConnection:${connectionId}] Message #${messageCount} sent - Size: ${jsonData.length} bytes, Duration: ${writeDuration}ms`);
-                                    
+
                                     if (writeDuration > 50) {
                                         console.warn(`[HttpConnection:${connectionId}] SLOW write operation - Duration: ${writeDuration}ms`);
                                     }
@@ -126,24 +126,19 @@ function getOrStream<U>(
                                 }
                             })
                             .done(() => {
-                                console.log(`[HttpConnection:${connectionId}] STREAM DONE - Messages sent: ${messageCount}, Client disconnected: ${clientDisconnected}, Timeout triggered: ${timeoutTriggered}`);
-                                
                                 clearTimeout(timeout);
                                 streamClosed = true;
-                                
+
+                                console.log(`[HttpConnection:${connectionId}] Stream ended - Messages sent: ${messageCount}, Duration: ${Date.now() - openedAt}ms, Reason: ${closedBy ?? "done"}`);
+
                                 try {
                                     if (!clientDisconnected) {
-                                        console.log(`[HttpConnection:${connectionId}] Ending socket connection`);
                                         res.socket?.end();
-                                    } else {
-                                        console.log(`[HttpConnection:${connectionId}] Client already disconnected - skipping socket end`);
                                     }
                                 } catch (error) {
                                     console.error(`[HttpConnection:${connectionId}] ERROR ending socket: ${error}`);
                                 }
                             });
-                        
-                        console.log(`[HttpConnection:${connectionId}] Stream handlers configured`);
                     }
                 })
                 .catch(error => {
@@ -152,16 +147,13 @@ function getOrStream<U>(
                 });
         }
         else {
-            console.log(`[HttpConnection:${connectionId}] Regular GET request`);
             getMethod(user, req.params, req.query)
                 .then(response => {
                     if (!response) {
-                        console.log(`[HttpConnection:${connectionId}] Get method returned null - sending 404`);
                         sendRouteMiss(res);
                         next();
                     }
                     else {
-                        console.log(`[HttpConnection:${connectionId}] Sending JSON response`);
                         res.type("json");
                         res.send(JSON.stringify(response));
                         next();

package/src/http/stream.ts

@@ -1,14 +1,18 @@
+// This class logs nothing on its success path. A stream's lifetime is reported
+// once by the request that opened it (see getOrStream in router.ts), and a line
+// per feed, per replayed item, or per done handler says the same thing again
+// once per unit of traffic. Issue #192: those per-item lines were 11.9% of a
+// 2.8-million-line production log. Failures still log, because a failed handler
+// is an event an operator cannot reconstruct from the summary.
 export class Stream<T> {
     private queue: T[] = [];
     private handlers: ((data: T) => void)[] = [];
     private doneHandlers: (() => void)[] = [];
     private closed = false;
     private readonly streamId: string;
-    private feedCount = 0;
 
     constructor() {
         this.streamId = Math.random().toString(36).substring(2, 10);
-        console.log(`[Stream:${this.streamId}] Created new stream`);
     }
 
     next(handler: (data: T) => void): Stream<T> {
@@ -16,21 +20,18 @@ export class Stream<T> {
             console.warn(`[Stream:${this.streamId}] Attempted to add handler to closed stream`);
             return this;
         }
-        
+
         this.handlers.push(handler);
-        const queueLength = this.queue.length;
-        console.log(`[Stream:${this.streamId}] Added handler - Total handlers: ${this.handlers.length}, Queued items: ${queueLength}`);
-        
+
         // Replay queued data to new handler
         this.queue.forEach((data, index) => {
             try {
                 handler(data);
-                console.log(`[Stream:${this.streamId}] Replayed queued item ${index + 1}/${queueLength} to new handler`);
             } catch (error) {
                 console.error(`[Stream:${this.streamId}] Error replaying queued item ${index + 1}: ${error}`);
             }
         });
-        
+
         return this;
     }
 
@@ -44,9 +45,8 @@ export class Stream<T> {
             }
             return this;
         }
-        
+
         this.doneHandlers.push(handler);
-        console.log(`[Stream:${this.streamId}] Added done handler - Total done handlers: ${this.doneHandlers.length}`);
         return this;
     }
 
@@ -55,70 +55,55 @@ export class Stream<T> {
             console.warn(`[Stream:${this.streamId}] Attempted to close already closed stream`);
             return;
         }
-        
-        console.log(`[Stream:${this.streamId}] CLOSING stream - Handlers: ${this.handlers.length}, Done handlers: ${this.doneHandlers.length}, Queue: ${this.queue.length}, Feed count: ${this.feedCount}`);
-        
+
         this.closed = true;
-        
+
         // Execute done handlers
-        const doneHandlerCount = this.doneHandlers.length;
         this.doneHandlers.forEach((handler, index) => {
             try {
                 handler();
-                console.log(`[Stream:${this.streamId}] Executed done handler ${index + 1}/${doneHandlerCount}`);
             } catch (error) {
                 console.error(`[Stream:${this.streamId}] Error in done handler ${index + 1}: ${error}`);
             }
         });
-        
+
         // Clear all references
         this.queue = [];
         this.handlers = [];
         this.doneHandlers = [];
-        
-        console.log(`[Stream:${this.streamId}] Stream closed and cleaned up`);
     }
 
     feed(data: any): void {
         const feedStart = Date.now();
-        
+
         if (this.closed) {
             console.warn(`[Stream:${this.streamId}] Attempted to feed data to closed stream - Data type: ${typeof data}`);
             return;
         }
-        
-        this.feedCount++;
+
         const handlerCount = this.handlers.length;
-        
-        console.log(`[Stream:${this.streamId}] FEEDING data - Feed #${this.feedCount}, Handlers: ${handlerCount}, Queue size before: ${this.queue.length}`);
-        
+
         this.queue.push(data);
-        
+
         // Notify all handlers
-        let successCount = 0;
-        let errorCount = 0;
-        
         this.handlers.forEach((handler, index) => {
             try {
                 const handlerStart = Date.now();
                 handler(data);
                 const handlerDuration = Date.now() - handlerStart;
-                successCount++;
-                
+
                 if (handlerDuration > 50) {
                     console.warn(`[Stream:${this.streamId}] SLOW handler - Handler ${index + 1}/${handlerCount}, Duration: ${handlerDuration}ms`);
                 }
             } catch (error) {
-                errorCount++;
                 console.error(`[Stream:${this.streamId}] ERROR in handler ${index + 1}/${handlerCount}: ${error}`);
             }
         });
-        
+
         const totalDuration = Date.now() - feedStart;
-        console.log(`[Stream:${this.streamId}] Feed complete - Success: ${successCount}, Errors: ${errorCount}, Queue size after: ${this.queue.length}, Duration: ${totalDuration}ms`);
-        
+
         if (totalDuration > 100) {
             console.warn(`[Stream:${this.streamId}] SLOW feed operation - Duration: ${totalDuration}ms`);
         }
     }
-}
+}

package/src/jinaga-server.ts

@@ -253,22 +253,82 @@ function getPool(uriOrPool: string | Pool, pools: { [uri: string]: Pool; }): Poo
     }
 }
 
+type PoolSettingDeclaration = {
+    variable: string,
+    defaultValue: number,
+    minimum: number
+};
+
+// The settings of a pool that this server builds for itself, each named by the
+// environment variable that sets it. A pool the caller supplies is used as
+// given, so none of these applies to it.
+const poolSettingDeclarations = {
+    // A pool of zero connections can serve nothing, so one is the minimum.
+    max: { variable: "POSTGRES_POOL_MAX", defaultValue: 10, minimum: 1 },
+    idleTimeoutMillis: { variable: "POSTGRES_IDLE_TIMEOUT_MILLIS", defaultValue: 30000, minimum: 0 },
+    // Zero means wait forever for a connection to come free.
+    connectionTimeoutMillis: { variable: "POSTGRES_CONNECTION_TIMEOUT_MILLIS", defaultValue: 0, minimum: 0 }
+} satisfies { [setting: string]: PoolSettingDeclaration };
+
+type PoolSettings = {
+    [setting in keyof typeof poolSettingDeclarations]: number
+};
+
+// The one rule by which every pool setting is read from the environment. An
+// absent or empty variable takes the default; anything that is not an integer
+// at or above the setting's minimum is refused rather than resolved, so the
+// environment either names a pool that can be built or no pool at all.
+function readPoolSetting({ variable, defaultValue, minimum }: PoolSettingDeclaration): number {
+    const value = process.env[variable];
+    if (value === undefined || value.trim() === '') {
+        return defaultValue;
+    }
+    const parsed = /^\d+$/.test(value.trim()) ? parseInt(value.trim(), 10) : NaN;
+    if (isNaN(parsed) || parsed < minimum) {
+        throw new Error(`The environment variable ${variable} is set to ${JSON.stringify(value)}, which is not an integer of at least ${minimum}.`);
+    }
+    return parsed;
+}
+
+function readPoolSettings(): PoolSettings {
+    return {
+        max: readPoolSetting(poolSettingDeclarations.max),
+        idleTimeoutMillis: readPoolSetting(poolSettingDeclarations.idleTimeoutMillis),
+        connectionTimeoutMillis: readPoolSetting(poolSettingDeclarations.connectionTimeoutMillis)
+    };
+}
+
 function createPool(postgresUri: string): Pool {
+    const settings = readPoolSettings();
     const postgresPool = new Pool({
         connectionString: postgresUri,
-        idleTimeoutMillis: process.env.POSTGRES_IDLE_TIMEOUT_MILLIS ?
-            parseInt(process.env.POSTGRES_IDLE_TIMEOUT_MILLIS) :
-            30000,
+        ...settings
     });
 
+    Trace.info(`Postgres pool created with max ${settings.max}, idleTimeoutMillis ${settings.idleTimeoutMillis}, connectionTimeoutMillis ${settings.connectionTimeoutMillis}`);
+
     tracePool(postgresPool);
 
     return postgresPool;
 }
 
+const poolWindowMilliseconds = 10000;
+
 export function tracePool(postgresPool: Pool) {
+    // Pool pressure is reported once per window of time rather than once per
+    // checkout, so the output rate no longer follows the acquire rate and no
+    // longer peaks when the pool is saturated. The window carries the largest
+    // waiting count it saw, so a spike that comes and goes inside one window
+    // still appears in the log.
+    let acquiredInWindow = false;
+    let peakWaiting = 0;
+
     postgresPool.on('acquire', (client) => {
-        Trace.metric('Postgres acquired', poolMetrics());
+        acquiredInWindow = true;
+        observeWaiting();
+    });
+    postgresPool.on('release', (err, client) => {
+        observeWaiting();
     });
     postgresPool.on('connect', (client) => {
         Trace.metric('Postgres connected', poolMetrics());
@@ -280,6 +340,34 @@ export function tracePool(postgresPool: Pool) {
         Trace.error(err);
     });
 
+    // The window closes on a timer so that a storm which stops in the middle
+    // of a window still reports its peak. The timer is unreferenced, so it
+    // does not hold the process open, and it stops once the pool has ended.
+    const windowTimer = setInterval(closeWindow, poolWindowMilliseconds);
+    windowTimer.unref?.();
+
+    function observeWaiting() {
+        if (postgresPool.waitingCount > peakWaiting) {
+            peakWaiting = postgresPool.waitingCount;
+        }
+    }
+
+    function closeWindow() {
+        if (postgresPool.ended) {
+            clearInterval(windowTimer);
+            return;
+        }
+        if (acquiredInWindow) {
+            const metrics = poolMetrics();
+            Trace.metric('Postgres pool', { ...metrics, peakWaiting });
+            if (peakWaiting > 0) {
+                Trace.warn(`Postgres pool saturated: ${peakWaiting} waiting at peak, ${metrics.waiting} waiting of ${metrics.total} at window close.`);
+            }
+        }
+        acquiredInWindow = false;
+        peakWaiting = 0;
+    }
+
     function poolMetrics() {
         return {
             total: postgresPool.totalCount,