Merge pull request #201 from codedogQBY/fix/feedback-log-too-large

fix(feedback): cap log bytes UTF-8-aware so feedback no longer 413s

Author: codedogQBY

packages/core/src/feedback/feedback-service.ts

@@ -32,6 +32,13 @@ const CONSOLE_LEVELS = ["debug", "info", "log", "warn", "error"] as const;
 const LOG_DIR = "logs";
 const LOG_FLUSH_INTERVAL_MS = 3000; // Flush to file every 3 seconds
 const LOG_MAX_DAYS = 7; // Keep 7 days of logs
+/**
+ * Tail-truncate the collected logs to this UTF-8 byte budget before
+ * submission. Sits below the worker's MAX_BODY_BYTES with room for the
+ * description (≤12_000 chars) + device info + JSON envelope, so a payload
+ * with maxed-out description never trips the worker's 413.
+ */
+const MAX_LOG_BYTES = 60_000;
 
 /** In-memory write buffer — flushed to file periodically */
 let _pendingLines: string[] = [];
@@ -217,6 +224,20 @@ function sanitizeLogLine(line: string): string {
   return line;
 }
 
+/**
+ * Tail-truncate a string to at most `maxBytes` UTF-8 bytes. Diagnostic logs
+ * are most useful at the END — we drop the older lines when oversize. Skips
+ * leading UTF-8 continuation bytes so the cut lands on a code-point boundary.
+ */
+export function truncateUtf8Tail(text: string, maxBytes: number): string {
+  const bytes = new TextEncoder().encode(text);
+  if (bytes.byteLength <= maxBytes) return text;
+  let offset = bytes.byteLength - maxBytes;
+  while (offset < bytes.byteLength && (bytes[offset] & 0xc0) === 0x80) offset++;
+  const dropped = offset;
+  return `[truncated: dropped ${dropped} bytes of older logs]\n${new TextDecoder().decode(bytes.slice(offset))}`;
+}
+
 /** Collect logs for feedback submission. Reads today's + yesterday's log files. */
 export async function collectLogs(options?: { sinceMs?: number }): Promise<string> {
   // First flush any pending lines
@@ -260,8 +281,10 @@ export async function collectLogs(options?: { sinceMs?: number }): Promise<strin
     return match[1] >= sinceTime;
   });
 
-  // Sanitize sensitive data before exposing logs externally
-  return lines.map(sanitizeLogLine).join("\n");
+  // Sanitize sensitive data before exposing logs externally, then tail-truncate
+  // to stay under the worker's MAX_BODY_BYTES (most recent lines are most relevant).
+  const sanitized = lines.map(sanitizeLogLine).join("\n");
+  return truncateUtf8Tail(sanitized, MAX_LOG_BYTES);
 }
 
 /** Clear all log files */

packages/feedback-worker/src/index.ts

@@ -50,8 +50,13 @@ interface GitHubCommentResponse {
 
 const MAX_TITLE_LENGTH = 120;
 const MAX_DESCRIPTION_LENGTH = 12_000;
-const MAX_LOG_LENGTH = 50_000;
-const MAX_BODY_BYTES = 80_000;
+/**
+ * Server-side safety net for logs: byte-based and tail-keep (newest lines
+ * matter most for diagnostics). Sized above the client's MAX_LOG_BYTES so
+ * an updated client never gets re-truncated here; old clients still cap.
+ */
+const MAX_LOG_BYTES = 80_000;
+const MAX_BODY_BYTES = 128_000;
 const DEFAULT_SUBMISSIONS_PER_DAY = 20;
 const DEFAULT_STATUS_REQUESTS_PER_HOUR = 120;
 
@@ -104,7 +109,7 @@ async function handleCreateFeedback(request: Request, env: Env): Promise<Respons
   const type = payload.type ?? "other";
   const title = requireText(payload.title, "title", MAX_TITLE_LENGTH);
   const description = requireText(payload.description, "description", MAX_DESCRIPTION_LENGTH);
-  const logs = truncateText(payload.logs?.trim() ?? "", MAX_LOG_LENGTH);
+  const logs = truncateLogTail(payload.logs?.trim() ?? "", MAX_LOG_BYTES);
 
   // Upload logs to Gist if present
   let gistUrl: string | undefined;
@@ -343,6 +348,19 @@ function truncateText(value: string, maxLength: number): string {
   return `${value.slice(0, maxLength)}\n\n[truncated]`;
 }
 
+/**
+ * Tail-truncate logs to at most `maxBytes` UTF-8 bytes. Diagnostic logs
+ * are most useful at the END, so we drop the older lines when oversize.
+ * Skips leading UTF-8 continuation bytes to land on a code-point boundary.
+ */
+function truncateLogTail(value: string, maxBytes: number): string {
+  const bytes = new TextEncoder().encode(value);
+  if (bytes.byteLength <= maxBytes) return value;
+  let offset = bytes.byteLength - maxBytes;
+  while (offset < bytes.byteLength && (bytes[offset] & 0xc0) === 0x80) offset++;
+  return `[truncated: dropped ${offset} bytes of older logs]\n${new TextDecoder().decode(bytes.slice(offset))}`;
+}
+
 function parseLabels(raw: string | undefined): string[] | undefined {
   const labels = raw
     ?.split(",")