raindrop-ai 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -1,9 +1,20 @@
 import {
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  MAX_RETRY_DELAY_MS,
+  POST_SHUTDOWN_TIMEOUT_MS,
+  SHUTDOWN_DEADLINE_MS,
+  capText,
   mirrorPartialEventToLocalDebugger,
   package_default,
+  raceWithTimeout,
+  rateLimitedLog,
+  redactUrlForLog,
   resolveLocalDebuggerBaseUrl,
+  resolveMaxTextFieldChars,
+  setDefaultMaxTextFieldChars,
+  stringifyBounded,
   tracing
-} from "./chunk-DP5ED5DR.mjs";
+} from "./chunk-UICWZEYM.mjs";
 import {
   __commonJS,
   __toESM
@@ -9957,7 +9968,6 @@ var PartialClientAiTrack = ClientAiTrack.extend({
 var AttachmentTypeSchema = z.enum(["code", "text", "image", "iframe"]);
 
 // src/index.ts
-process.env.TRACELOOP_TELEMETRY = "false";
 var MAX_INGEST_SIZE_BYTES = 1 * 1024 * 1024;
 var SELF_DIAGNOSTICS_TOOL_NAME_DEFAULT = "__raindrop_report";
 var SELF_DIAGNOSTICS_SOURCE_DEFAULT = "agent_reporting_tool";
@@ -10082,12 +10092,12 @@ function parseRetryAfter(headers) {
 }
 function getRetryDelayMs(attemptNumber, previousError) {
   if (previousError && typeof previousError.retryAfterMs === "number") {
-    return Math.max(0, previousError.retryAfterMs);
+    return Math.min(Math.max(0, previousError.retryAfterMs), MAX_RETRY_DELAY_MS);
   }
   if (attemptNumber <= 1) return 0;
   const base = 500;
   const factor = Math.pow(2, attemptNumber - 2);
-  return base * factor;
+  return Math.min(base * factor, MAX_RETRY_DELAY_MS);
 }
 async function withRetry(operation, opName, maxAttempts, debugLogs = false) {
   var _a;
@@ -10126,7 +10136,16 @@ var Raindrop = class {
     this.partialEventBuffer = /* @__PURE__ */ new Map();
     this.partialEventTimeouts = /* @__PURE__ */ new Map();
     this.inFlightRequests = /* @__PURE__ */ new Set();
+    /**
+     * Set once `close()` begins and never cleared. Sends issued after the
+     * drain window (stragglers, or flush work the deadline abandoned
+     * mid-drain) run as a single short attempt instead of regaining the full
+     * retry schedule.
+     */
+    this.hasShutdown = false;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    setDefaultMaxTextFieldChars(config.maxTextFieldChars);
+    this.maxTextFieldChars = resolveMaxTextFieldChars(config.maxTextFieldChars);
     this.writeKey = (_a = config.writeKey) != null ? _a : "";
     this.localDebuggerUrlOpt = config.localWorkshopUrl === false ? null : config.localWorkshopUrl;
     this.apiUrl = (_b = this.formatEndpoint(config.endpoint)) != null ? _b : `https://api.raindrop.ai/v1/`;
@@ -10349,14 +10368,16 @@ var Raindrop = class {
         eventId,
         userId,
         model,
-        input,
-        output,
+        input: rawInput,
+        output: rawOutput,
         convoId,
         attachments,
         properties,
         timestamp,
         ...rest
       } = e;
+      const input = capText(rawInput, this.maxTextFieldChars);
+      const output = capText(rawOutput, this.maxTextFieldChars);
       const customEventId = eventId != null ? eventId : crypto.randomUUID();
       const parsedAttachments = AttachmentSchema.array().safeParse(attachments != null ? attachments : []);
       if (!parsedAttachments.success) {
@@ -10563,20 +10584,51 @@ var Raindrop = class {
       void fetch(`${localUrl}${endpoint}`, {
         method: "POST",
         headers,
-        body: JSON.stringify(body)
+        body: JSON.stringify(body),
+        // Bounded like the cloud paths: a black-holed Workshop URL must not
+        // pin connections indefinitely (fire-and-forget still holds sockets).
+        signal: AbortSignal.timeout(DEFAULT_REQUEST_TIMEOUT_MS)
       }).catch(() => {
       });
     } catch (e) {
     }
   }
+  /**
+   * Attempts/timeout budget for one POST, honoring the close() deadline.
+   * Returns `null` when the shutdown budget is exhausted — the caller must
+   * drop the payload instead of issuing a request that could outlive
+   * process exit. Checked fresh on every send so a deadline that expires
+   * mid-drain takes effect immediately.
+   */
+  requestBudget() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return { maxAttempts: 1, timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs) };
+    }
+    if (this.hasShutdown) {
+      return { maxAttempts: 1, timeoutMs: POST_SHUTDOWN_TIMEOUT_MS };
+    }
+    return { maxAttempts: 3, timeoutMs: DEFAULT_REQUEST_TIMEOUT_MS };
+  }
+  warnShutdownDrop(what) {
+    rateLimitedLog(
+      "js-sdk.shutdown_deadline",
+      () => console.warn(`[raindrop] shutdown flush deadline exceeded; dropping ${what}`)
+    );
+  }
   async sendBatchToApi(events, endpoint) {
-    var _a;
     const body = events.map(({ type, ...event }) => event);
     this.mirrorBatchToLocalDebugger(endpoint, body);
     if (this.localOnly) {
       return;
     }
-    const opName = `POST ${endpoint}`;
+    const opName = `POST ${redactUrlForLog(this.apiUrl + endpoint)}`;
+    const budget = this.requestBudget();
+    if (!budget) {
+      this.warnShutdownDrop(`${events.length} event(s) for ${endpoint}`);
+      return;
+    }
     try {
       const response = await withRetry(
         async () => {
@@ -10586,7 +10638,11 @@ var Raindrop = class {
               "Content-Type": "application/json",
               Authorization: `Bearer ${this.writeKey}`
             },
-            body: JSON.stringify(body)
+            body: JSON.stringify(body),
+            // Bounded: a dead or black-holed endpoint must never pin this
+            // request (and the flush/close paths awaiting it) until the OS
+            // gives up.
+            signal: AbortSignal.timeout(budget.timeoutMs)
           });
           if (!resp.ok) {
             const text = await resp.text().catch(() => "");
@@ -10600,7 +10656,7 @@ var Raindrop = class {
           return resp;
         },
         opName,
-        3,
+        budget.maxAttempts,
         this.debugLogs
       );
       if (this.debugLogs) {
@@ -10609,9 +10665,18 @@ var Raindrop = class {
       return response;
     } catch (error) {
       if (error == null ? void 0 : error.response) {
-        console.error(`[raindrop] Error in response (${opName}): ` + error.response.data);
+        rateLimitedLog(
+          `js-sdk.batch_failed.${endpoint}`,
+          () => console.error(`[raindrop] Error in response (${opName}): ` + error.response.data)
+        );
       } else {
-        console.error(`[raindrop] Error (${opName}): ` + ((_a = error == null ? void 0 : error.message) != null ? _a : String(error)));
+        rateLimitedLog(
+          `js-sdk.batch_failed.${endpoint}`,
+          () => {
+            var _a;
+            return console.error(`[raindrop] Error (${opName}): ` + ((_a = error == null ? void 0 : error.message) != null ? _a : String(error)));
+          }
+        );
       }
     }
   }
@@ -10668,6 +10733,12 @@ var Raindrop = class {
       console.warn("[raindrop] trackAiPartial requires an eventId.");
       return Promise.resolve();
     }
+    if (typeof rest.input === "string") {
+      rest.input = capText(rest.input, this.maxTextFieldChars);
+    }
+    if (typeof rest.output === "string") {
+      rest.output = capText(rest.output, this.maxTextFieldChars);
+    }
     const existingEvent = this.partialEventBuffer.get(eventId) || {};
     const mergedEvent = this.deepMergeObjects(
       { ...existingEvent },
@@ -10698,7 +10769,7 @@ var Raindrop = class {
     this.partialEventTimeouts.set(eventId, newTimeout);
     if (this.debugLogs) {
       console.log(
-        `[raindrop] Updated partial event buffer for eventId: ${eventId}. Timeout reset (20s). Event: ${JSON.stringify(mergedEvent)}`
+        `[raindrop] Updated partial event buffer for eventId: ${eventId}. Timeout reset (2s). Event: ${stringifyBounded(mergedEvent, 2e3)}`
       );
     }
     return Promise.resolve();
@@ -10714,9 +10785,12 @@ var Raindrop = class {
     try {
       await flushPromise;
     } catch (error) {
-      console.error(
-        `[raindrop] Failed to flush partial event ${eventId}:`,
-        error instanceof Error ? error : String(error)
+      rateLimitedLog(
+        "js-sdk.partial_flush_failed",
+        () => console.error(
+          `[raindrop] Failed to flush partial event ${eventId}:`,
+          error instanceof Error ? error : String(error)
+        )
       );
     } finally {
       this.inFlightRequests.delete(flushPromise);
@@ -10784,7 +10858,7 @@ var Raindrop = class {
     const parsed = PartialClientAiTrack.partial().safeParse(eventToSend);
     if (!parsed.success) {
       console.warn(
-        `[raindrop] Invalid accumulated data for partial eventId ${eventId}. Event not sent. Errors: ${this.formatZodError(parsed.error)} Data: ${JSON.stringify(eventToSend)}`
+        `[raindrop] Invalid accumulated data for partial eventId ${eventId}. Event not sent. Errors: ${this.formatZodError(parsed.error)} Data: ${stringifyBounded(eventToSend, 2e3)}`
       );
       return;
     }
@@ -10808,7 +10882,6 @@ var Raindrop = class {
    * @param event - The event data conforming to ClientAiTrack schema.
    */
   async sendPartialEvent(event) {
-    var _a;
     const endpoint = "events/track_partial";
     const opName = `POST ${endpoint}`;
     mirrorPartialEventToLocalDebugger(event, {
@@ -10820,6 +10893,11 @@ var Raindrop = class {
     if (this.localOnly) {
       return;
     }
+    const budget = this.requestBudget();
+    if (!budget) {
+      this.warnShutdownDrop(`partial event ${event.event_id}`);
+      return;
+    }
     try {
       const response = await withRetry(
         async () => {
@@ -10829,8 +10907,10 @@ var Raindrop = class {
               "Content-Type": "application/json",
               Authorization: `Bearer ${this.writeKey}`
             },
-            body: JSON.stringify(event)
+            body: JSON.stringify(event),
             // Send the single event object
+            // Bounded: see sendBatchToApi.
+            signal: AbortSignal.timeout(budget.timeoutMs)
           });
           if (!resp.ok) {
             const errorBody = await resp.text().catch(() => "");
@@ -10844,7 +10924,7 @@ var Raindrop = class {
           return resp;
         },
         opName,
-        3,
+        budget.maxAttempts,
         this.debugLogs
       );
       if (this.debugLogs) {
@@ -10854,8 +10934,14 @@ var Raindrop = class {
       }
       return response;
     } catch (error) {
-      console.error(
-        `[raindrop] Failed to send partial event ${event.event_id} to ${endpoint}: ${(_a = error == null ? void 0 : error.message) != null ? _a : String(error)}`
+      rateLimitedLog(
+        "js-sdk.partial_failed",
+        () => {
+          var _a;
+          return console.error(
+            `[raindrop] Failed to send partial event ${event.event_id} to ${endpoint}: ${(_a = error == null ? void 0 : error.message) != null ? _a : String(error)}`
+          );
+        }
       );
       throw error;
     }
@@ -10874,7 +10960,21 @@ var Raindrop = class {
     }
   }
   async close() {
-    await this._tracing.close();
+    this.hasShutdown = true;
+    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    try {
+      await this.closeWithinDeadline();
+    } finally {
+      this.shutdownDeadlineAt = void 0;
+    }
+  }
+  async closeWithinDeadline() {
+    const remainingMs = () => {
+      var _a;
+      return Math.max(0, ((_a = this.shutdownDeadlineAt) != null ? _a : Date.now()) - Date.now());
+    };
+    const tracingSettled = await raceWithTimeout(this._tracing.close(), remainingMs());
+    if (!tracingSettled) this.warnShutdownDrop("in-flight trace flush");
     try {
       await this.flush();
     } catch (error) {
@@ -10903,7 +11003,12 @@ var Raindrop = class {
         );
       }
       try {
-        await Promise.all(Array.from(this.inFlightRequests));
+        const settled = await raceWithTimeout(
+          Promise.allSettled(Array.from(this.inFlightRequests)).then(() => {
+          }),
+          remainingMs()
+        );
+        if (!settled) this.warnShutdownDrop("in-flight partial event request(s)");
       } catch (e) {
         console.error(`[raindrop] Error waiting for in-flight requests:`, e);
       }