jinaga-server 3.7.4 → 3.8.0

package/src/http/router.ts

@@ -22,6 +22,7 @@ import {
     LoadResponse,
     parseLoadMessage,
     parseSaveMessage,
+    PredecessorNotResolvedError,
     ProfileMessage,
     ProjectedResult,
     ReferencesByName,
@@ -40,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>)
@@ -48,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`);
-                        res.sendStatus(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`);
                                     }
@@ -125,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 => {
@@ -151,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`);
-                        res.sendStatus(404);
+                        sendRouteMiss(res);
                         next();
                     }
                     else {
-                        console.log(`[HttpConnection:${connectionId}] Sending JSON response`);
                         res.type("json");
                         res.send(JSON.stringify(response));
                         next();
@@ -199,9 +192,14 @@ function post<T, U>(
 ): Handler {
     return (req, res, next) => {
         const user = <RequestUser>(req as any).user;
-        const message = parse(req.body);
+        const parsed = parseRequestInput(() => parse(req.body), req, res, next);
+        if (!parsed.ok) {
+            return;
+        }
+        const message = parsed.value;
         if (!message) {
-            throw new Error('Ensure that you have called app.use(express.json()).');
+            handleError(new Invalid(`${MISSING_BODY} ${describeContentType(req)}`), req, res, next);
+            return;
         }
         method(user, message, req.params)
             .then(response => {
@@ -224,8 +222,11 @@ function postCreate<T>(
 ): Handler {
     return (req, res, next) => {
         const user = <RequestUser>(req as any).user;
-        const message = parse(req);
-        method(user, message)
+        const parsed = parseRequestInput(() => parse(req), req, res, next);
+        if (!parsed.ok) {
+            return;
+        }
+        method(user, parsed.value)
             .then(_ => {
                 res.sendStatus(201);
                 next();
@@ -237,19 +238,16 @@ function postCreate<T>(
 function postStringCreate(method: (user: RequestUser, message: string) => Promise<void>): Handler {
     return (req, res, next) => {
         const user = <RequestUser>(req as any).user;
-        const input = parseString(req.body);
-        if (!input || typeof (input) !== 'string') {
-            res.type("text");
-            res.status(500).send('Expected Content-Type text/plain. Ensure that you have called app.use(express.text()).');
-        }
-        else {
-            method(user, input)
-                .then(_ => {
-                    res.sendStatus(201);
-                    next();
-                })
-                .catch(error => handleError(error, req, res, next));
+        const parsed = parseRequestInput(() => parseTextBody(req), req, res, next);
+        if (!parsed.ok) {
+            return;
         }
+        method(user, parsed.value)
+            .then(_ => {
+                res.sendStatus(201);
+                next();
+            })
+            .catch(error => handleError(error, req, res, next));
     };
 }
 
@@ -261,29 +259,27 @@ function postReadWithStreaming(
 ): Handler {
     return (req, res, next) => {
         const user = <RequestUser>(req as any).user;
-        const input = parseString(req.body);
-        if (!input || typeof (input) !== 'string') {
-            res.type("text");
-            res.status(500).send('Expected Content-Type text/plain. Ensure that you have called app.use(express.text()).');
+        const parsed = parseRequestInput(() => parseTextBody(req), req, res, next);
+        if (!parsed.ok) {
+            return;
         }
-        else {
-            // Check if Accept header explicitly prefers a specific format
-            const acceptHeader = req.get('Accept');
-            let acceptType: string = 'text/plain'; // Default for backward compatibility
-
-            if (acceptHeader && acceptHeader !== '*/*') {
-                // Only use req.accepts() when there's a specific preference
-                const preferredType = req.accepts(['text/csv', 'application/x-ndjson', 'application/json', 'text/plain']);
-                acceptType = preferredType ? String(preferredType) : 'text/plain';
-            }
-            
-            method(user, input, acceptType)
-                .then(({resultStream, csvMetadata}) => {
-                    outputReadResults(resultStream, res, acceptType, csvMetadata);
-                    next();
-                })
-                .catch(error => handleError(error, req, res, next));
+
+        // Check if Accept header explicitly prefers a specific format
+        const acceptHeader = req.get('Accept');
+        let acceptType: string = 'text/plain'; // Default for backward compatibility
+
+        if (acceptHeader && acceptHeader !== '*/*') {
+            // Only use req.accepts() when there's a specific preference
+            const preferredType = req.accepts(['text/csv', 'application/x-ndjson', 'application/json', 'text/plain']);
+            acceptType = preferredType ? String(preferredType) : 'text/plain';
         }
+
+        method(user, parsed.value, acceptType)
+            .then(({resultStream, csvMetadata}) => {
+                outputReadResults(resultStream, res, acceptType, csvMetadata);
+                next();
+            })
+            .catch(error => handleError(error, req, res, next));
     };
 }
 
@@ -313,7 +309,7 @@ function inputSaveMessage(req: Request): GraphSource {
             read: async (onEnvelopes) => {
                 const message = parseSaveMessage(req.body);
                 if (!message) {
-                    throw new Error('Ensure that you have called app.use(express.json()).');
+                    throw new Invalid(MISSING_JSON_BODY);
                 }
                 await onEnvelopes(message.facts.map(fact => ({
                     fact: fact,
@@ -358,7 +354,9 @@ function outputReadResults(
         .catch(error => {
             console.error('Error in outputReadResults:', error);
             if (!res.headersSent) {
-                res.status(500).send('Internal server error');
+                // Without an explicit type, res.send of a string makes Express
+                // infer text/html and label an error body as markup.
+                res.type("text").status(500).send('Internal server error');
             }
         });
 }
@@ -550,11 +548,19 @@ export class HttpRouter {
             }
 
             const userIdentity = serializeUserIdentity(user);
-            await this.authorization.save(userIdentity, factRecords
+            const envelopes: FactEnvelope[] = factRecords
                 .map(fact => ({
                     fact: fact,
                     signatures: []
-                })));
+                }));
+            try {
+                await this.authorization.save(userIdentity, envelopes);
+            } catch (error) {
+                // /write reaches the same authorization path as /save, so it
+                // needs the same translation of predecessor-resolution
+                // failures into a diagnosable 4xx (issue #182 finding 2).
+                throw toSaveAuthorizationError(error, envelopes);
+            }
         });
     }
 
@@ -988,34 +994,174 @@ export class FeedNotFound extends Error {
     }
 }
 
+// Both message shapes below are matched by prose, because jinaga reports a
+// missing predecessor as a plain Error. That is fragile: an upstream wording
+// change silently turns these back into 500s (issue #182 finding 5). The
+// end-to-end cases in test/http/errorStatusMappingSpec.ts drive the real
+// AuthorizationEngine so that drift fails the build.
+//
+// jinaga 6.11.3 landed the typed errors of jinaga.js#234, so the topological
+// sort's failure is now an instanceof check below. One prose pattern remains:
+// specification-runner still reports its missing fact as a plain Error.
+
 // Authorization rule evaluation reports a missing predecessor as a plain
-// Error of this shape (see authorizationRules.ts / specification-runner.ts
-// in jinaga). It surfaces when the client's save request didn't include the
-// full closure of facts a rule needs to walk. Map it to a diagnosable 4xx
-// instead of an opaque 500 (issue #175).
+// Error of this shape (specification-runner.ts in jinaga, still untyped as of
+// 6.11.3). It surfaces when the client's save request didn't include the full
+// closure of facts a rule needs to walk. Map it to a diagnosable 4xx instead
+// of an opaque 500 (issue #175).
 const FACT_NOT_DEFINED_PATTERN = /^The fact (\S+):(\S+) is not defined\.$/;
 
 function toSaveAuthorizationError(error: any, envelopes: FactEnvelope[]): any {
-    if (error instanceof Error) {
-        const match = FACT_NOT_DEFINED_PATTERN.exec(error.message);
-        if (match) {
-            const [, factType, factHash] = match;
-            const factTypesInBatch = Array.from(new Set(envelopes.map(e => e.fact.type))).join(", ");
-            Trace.warn(
-                `Save authorization could not resolve predecessor ${factType}:${factHash} ` +
-                `among ${envelopes.length} fact(s) in the request (types: ${factTypesInBatch}).`
+    if (!(error instanceof Error)) {
+        return error;
+    }
+
+    const describeBatch = () => {
+        const factTypesInBatch = Array.from(new Set(envelopes.map(e => e.fact.type))).join(", ");
+        return `${envelopes.length} fact(s) in the request (types: ${factTypesInBatch})`;
+    };
+
+    // The batch named a predecessor that is in neither the batch nor storage,
+    // so the topological sort could never reach the facts that depend on it.
+    // A client data problem, not a server fault (issue #182 finding 1).
+    if (error instanceof PredecessorNotResolvedError) {
+        const missing = error.missingPredecessors.map(r => `${r.type}:${r.hash}`);
+        const unresolved = error.unresolvedFacts.map(r => `${r.type}:${r.hash}`);
+        Trace.warn(
+            `Save authorization could not resolve ${missing.length} predecessor(s) [${missing.join(", ")}] ` +
+            `needed by ${unresolved.length} fact(s) [${unresolved.join(", ")}] among ${describeBatch()}.`
+        );
+        const advice = `Send the full closure of predecessors together, or commit the predecessors first.`;
+        if (missing.length === 1) {
+            return new Invalid(
+                `The fact ${missing[0]} is named as a predecessor, but it was not found in storage ` +
+                `and was not included in the request. ${advice}`
             );
+        }
+        if (missing.length > 1) {
             return new Invalid(
-                `The fact ${factType}:${factHash} is required to authorize this save but was not included in the request. ` +
-                `Ensure the full closure of predecessors needed by your authorization rules is sent together.`
+                `${missing.length} facts are named as predecessors, but they were not found in storage ` +
+                `and were not included in the request: ${missing.join(", ")}. ${advice}`
             );
         }
+        // The engine could not attribute the failure to specific references.
+        return new Invalid(
+            `${unresolved.length} fact(s) could not be authorized because one or more predecessors ` +
+            `were not found in storage and were not included in the request. ${advice}`
+        );
+    }
+
+    const notDefined = FACT_NOT_DEFINED_PATTERN.exec(error.message);
+    if (notDefined) {
+        const [, factType, factHash] = notDefined;
+        Trace.warn(
+            `Save authorization could not resolve predecessor ${factType}:${factHash} ` +
+            `among ${describeBatch()}.`
+        );
+        return new Invalid(
+            `The fact ${factType}:${factHash} is required to authorize this save but was not included in the request. ` +
+            `Ensure the full closure of predecessors needed by your authorization rules is sent together.`
+        );
     }
+
     return error;
 }
 
+// post() serves both a JSON route (/load) and a text route (/feeds), so its
+// message names no particular parser; the single-content-type entry points
+// keep the specific hint they have always given.
+const MISSING_BODY = 'The request body is empty or could not be read. Ensure that the body parser for this Content-Type is registered.';
+const MISSING_JSON_BODY = 'Ensure that you have called app.use(express.json()).';
+const MISSING_TEXT_BODY = 'Expected Content-Type text/plain. Ensure that you have called app.use(express.text()).';
+
+// A request body that fails to parse is a client error. Both this module's
+// parseString and jinaga's message parsers signal that by throwing
+// synchronously from the handler, where Express hands it to its default error
+// handler and reports 500. Classify parse failures as Invalid so handleError
+// renders a 400 (issue #182 finding 3).
+function toInvalidInput(error: any): Invalid {
+    if (error instanceof Invalid) {
+        return error;
+    }
+    return new Invalid(error instanceof Error ? error.message : String(error));
+}
+
+// /read and /write accept text/plain only, so every unreadable body there has
+// the same cause and deserves the same actionable hint. Checking req.body here
+// rather than deferring to parseString keeps a missing body parser — the common
+// misconfiguration — from being reported with parseString's generic
+// content-type message.
+function parseTextBody(req: Request): string {
+    const body = req.body;
+    if (typeof body !== 'string' || !body) {
+        throw new Invalid(`${MISSING_TEXT_BODY} ${describeContentType(req)}`);
+    }
+    return body;
+}
+
+// Naming what arrived turns "check your setup" into something the caller can
+// act on without guessing which end is misconfigured. The value is echoed from
+// the request, so cap it: a real content type is short, and the body should
+// not grow with whatever the caller chose to send.
+const MAX_ECHOED_CONTENT_TYPE = 80;
+
+function describeContentType(req: Request): string {
+    const contentType = req.get('Content-Type');
+    if (!contentType) {
+        return `No Content-Type header was received.`;
+    }
+    const echoed = contentType.length > MAX_ECHOED_CONTENT_TYPE
+        ? `${contentType.substring(0, MAX_ECHOED_CONTENT_TYPE)}…`
+        : contentType;
+    return `Received Content-Type: ${echoed}.`;
+}
+
+function parseRequestInput<T>(
+    parse: () => T,
+    req: Request,
+    res: Response,
+    next: NextFunction
+): { ok: true, value: T } | { ok: false } {
+    try {
+        return { ok: true, value: parse() };
+    } catch (error) {
+        handleError(toInvalidInput(error), req, res, next);
+        return { ok: false };
+    }
+}
+
+// A route miss (no :hash in the URL) is a 404 just like a feed-cache miss,
+// but for a different reason. Send a machine-readable body so a client can
+// always tell "wrong URL" from "re-subscribe via POST /feeds" (issue #182
+// finding 6); handleError sends "feed_not_found" for the latter.
+function sendRouteMiss(res: Response) {
+    res.type("text");
+    res.status(404).send("not_found");
+}
+
+// These bodies are diagnostics, not markup, but they quote client-supplied
+// text: a Content-Type header, a fact type named in a parse failure. The
+// response is text/plain and marked nosniff, yet that is the content type
+// saying so — neutralize the characters that could start markup here, at the
+// one place every error body is written, so the guarantee does not rest on a
+// header a proxy or a later edit could change. Quotes are left alone: they
+// only matter inside a tag, which escaping '<' already prevents, and messages
+// quote identifiers routinely.
+const HTML_META_CHARACTERS: { [character: string]: string } = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;"
+};
+
+function sanitizeErrorBody(message: string): string {
+    return message.replace(/[&<>]/g, character => HTML_META_CHARACTERS[character]);
+}
+
 function handleError(error: any, req: Request, res: Response, next: NextFunction) {
     const requestPath = req.path;
+    // Error bodies are plain text built partly from client-supplied input, so
+    // stop a browser from sniffing one as markup.
+    res.set("X-Content-Type-Options", "nosniff");
     if (error instanceof FeedNotFound) {
         Trace.warn(`Feed not found: ${error.feedHash} (Path: ${requestPath})`);
         res.type("text");
@@ -1023,15 +1169,19 @@ function handleError(error: any, req: Request, res: Response, next: NextFunction
     } else if (error instanceof Forbidden) {
         Trace.warn(`Forbidden: ${error.message} (Path: ${requestPath})`);
         res.type("text");
-        res.status(403).send(error.message);
+        res.status(403).send(sanitizeErrorBody(error.message));
     } else if (error instanceof Invalid) {
         Trace.warn(`Invalid: ${error.message} (Path: ${requestPath})`);
         res.type("text");
-        res.status(400).send(error.message);
+        res.status(400).send(sanitizeErrorBody(error.message));
     } else {
+        // Classification above is an allow-list, so anything reaching here is
+        // unclassified — including genuine internal failures whose message can
+        // name internal hosts or credentials. Keep the detail in the trace and
+        // send a generic body to the caller (issue #182 finding 4).
         Trace.error(`Error: ${error.message} (Path: ${requestPath})`);
         res.type("text");
-        res.status(500).send(error.message);
+        res.status(500).send("Internal server error");
     }
     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`);
         }
     }
-}
+}