@nosana/node 1.1.68-rc → 1.1.69-rc

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nosana/node",
-    "version": "1.1.68-rc",
+    "version": "1.1.69-rc",
     "description": "",
     "bin": {
         "nosana-node": "./dist/src/index.js"

package/dist/src/NodeManager/node/api/routes/wss/log.d.ts

@@ -6,9 +6,12 @@ import WebSocket from 'ws';
 export declare function wssLogRoute(ws: WebSocket, _: string, { jobAddress }: {
     jobAddress: string;
 }): Promise<void>;
-export declare function wssTaskManagerLogRoute(ws: WebSocket, _: string, { jobAddress, group, opId, type, }: {
+export declare function wssTaskManagerLogRoute(ws: WebSocket, _: string, { jobAddress, group, opId, type, since, limit, }: {
     jobAddress: string;
     group?: string;
     opId?: string;
     type?: string;
+    /** Only logs written after this epoch-millisecond mark. */
+    since?: number;
+    limit?: number;
 }): Promise<void>;

package/dist/src/NodeManager/node/api/routes/wss/log.js

@@ -3,6 +3,12 @@ import { sleep } from '@nosana/sdk';
 import { logStreaming } from '../../../../monitoring/streaming/LogStreamer.js';
 import { getSDK } from '../../../../sdk/index.js';
 import { TaskManagerRegistry } from '../../../task/TaskManagerRegistry.js';
+/**
+ * Lines of history a client gets when it doesn't ask for a number. A service
+ * that has run for hours has more log than a viewer can use, and every line
+ * costs a frame, so the recent end is sent and the rest is left to `since`.
+ */
+const DEFAULT_REPLAY_LIMIT = 5000;
 /**
  * this is for log streaming, this is going to be used by the basic job poster
  * just to show that clients logs, both from the node and the container
@@ -12,7 +18,7 @@ export async function wssLogRoute(ws, _, { jobAddress }) {
     const walletAddress = sdk.solana.wallet.toString();
     logStreaming(walletAddress).subscribe(ws, jobAddress);
 }
-export async function wssTaskManagerLogRoute(ws, _, { jobAddress, group, opId, type, }) {
+export async function wssTaskManagerLogRoute(ws, _, { jobAddress, group, opId, type, since, limit, }) {
     const registry = TaskManagerRegistry.getInstance();
     const deadline = Date.now() + 30000;
     let task = registry.get(jobAddress);
@@ -30,12 +36,21 @@ export async function wssTaskManagerLogRoute(ws, _, { jobAddress, group, opId, t
             (!opId || log.opId === opId) &&
             (!type || log.type === type));
     });
-    // Send historical logs first (optional)
-    const logs = opId
-        ? task.getLogsByOp(opId)
+    const cap = typeof limit === 'number' && isFinite(limit) && limit > 0
+        ? Math.floor(limit)
+        : DEFAULT_REPLAY_LIMIT;
+    // Historical logs are replayed before the socket returns to the event loop,
+    // so a live line can never land among them.
+    let logs = opId
+        ? task.getLogsByOp(opId, cap)
         : group
-            ? task.getLogsByGroup(group)
-            : task.getAllLogs();
+            ? task.getLogsByGroup(group, cap)
+            : task.getAllLogs(cap);
+    // `cap` already took the newest lines, so this can only trim that window
+    // further — never reach past it for more.
+    if (typeof since === 'number' && isFinite(since)) {
+        logs = logs.filter((log) => log.timestamp > since);
+    }
     for (const log of logs) {
         try {
             ws.send(JSON.stringify({ path: 'flog', data: JSON.stringify(log) }));

package/dist/src/NodeManager/node/task/TaskManager.d.ts

@@ -223,9 +223,10 @@ export default class TaskManager {
     getCurrentGroupStatus: () => Record<string, string | null>;
     getGroupStatus: (group: string) => Record<string, string | null>;
     addlog: (log: TaskLog) => void;
-    getLogsByOp: (opid: string) => TaskLog[];
-    getLogsByGroup: (group: string) => TaskLog[];
-    getAllLogs: () => TaskLog[];
+    /** `limit` keeps the newest logs; the read costs the size of that window. */
+    getLogsByOp: (opid: string, limit?: number) => TaskLog[];
+    getLogsByGroup: (group: string, limit?: number) => TaskLog[];
+    getAllLogs: (limit?: number) => TaskLog[];
     subscribe: (ws: WebSocket, matcher: (log: TaskLog) => boolean) => void;
     unsubscribe: (ws: WebSocket) => void;
     addStat: (stat: TaskStat) => void;

package/dist/src/NodeManager/node/task/loggers/logManager.d.ts

@@ -1,8 +1,8 @@
 import TaskManager, { TaskLog } from '../TaskManager.js';
 import WebSocket from 'ws';
 export declare function addLog(this: TaskManager, log: TaskLog): void;
-export declare function getLogsByOp(this: TaskManager, opId: string): TaskLog[];
-export declare function getLogsByGroup(this: TaskManager, group: string): TaskLog[];
-export declare function getAllLogs(this: TaskManager): TaskLog[];
+export declare function getLogsByOp(this: TaskManager, opId: string, limit?: number): TaskLog[];
+export declare function getLogsByGroup(this: TaskManager, group: string, limit?: number): TaskLog[];
+export declare function getAllLogs(this: TaskManager, limit?: number): TaskLog[];
 export declare function subscribe(this: TaskManager, ws: WebSocket, matcher: (log: TaskLog) => boolean): void;
 export declare function unsubscribe(this: TaskManager, ws: WebSocket): void;

package/dist/src/NodeManager/node/task/loggers/logManager.js

@@ -1,4 +1,14 @@
-const MAX_LOGS_PER_OP = 10000000;
+/**
+ * Per-operation replay buffer. A long-running service logs for as long as it
+ * runs, so this is a memory bound, not a history: the full log of a finished
+ * job is read back from its results, not from here.
+ */
+const MAX_LOGS_PER_OP = 20000;
+/**
+ * Dropping one line per push once at the cap moves the whole buffer each time,
+ * so room is made in blocks instead.
+ */
+const TRIM_BLOCK = 2000;
 // Ensure strictly increasing timestamps per TaskManager to avoid mis-ordered logs
 const lastTimestampByTask = new WeakMap();
 export function addLog(log) {
@@ -16,8 +26,9 @@ export function addLog(log) {
     }
     const buffer = this.opLogBuffers.get(log.opId);
     buffer.push(log);
-    if (buffer.length > MAX_LOGS_PER_OP)
-        buffer.shift();
+    if (buffer.length > MAX_LOGS_PER_OP + TRIM_BLOCK) {
+        buffer.splice(0, buffer.length - MAX_LOGS_PER_OP);
+    }
     for (const ws of this.subscribers) {
         const matcher = this.logMatchers.get(ws);
         if (matcher && matcher(log)) {
@@ -28,18 +39,51 @@ export function addLog(log) {
         }
     }
 }
-export function getLogsByOp(opId) {
-    return this.opLogBuffers.get(opId) || [];
-}
-export function getLogsByGroup(group) {
-    const logs = [];
-    for (const buffer of this.opLogBuffers.values()) {
-        logs.push(...buffer.filter((log) => log.group === group));
+/**
+ * Each buffer holds one operation's logs in the order they were written, so a
+ * read spanning operations has to interleave the buffers rather than join them
+ * end to end. Walking back from the newest of each costs the length of the
+ * answer rather than the length of the history, and `addLog` giving every log
+ * in a TaskManager a unique, increasing timestamp is what orders them.
+ */
+function mergeRecent(buffers, limit, match) {
+    // One cursor per buffer, each starting at that buffer's newest log.
+    const cursors = buffers.map((buffer) => ({ buffer, at: buffer.length - 1 }));
+    const merged = [];
+    while (merged.length < limit) {
+        let from;
+        let newest;
+        for (const cursor of cursors) {
+            const candidate = cursor.at < 0 ? undefined : cursor.buffer[cursor.at];
+            if (!candidate)
+                continue;
+            if (!newest || candidate.timestamp > newest.timestamp) {
+                newest = candidate;
+                from = cursor;
+            }
+        }
+        if (!from || !newest)
+            break;
+        from.at--;
+        if (!match || match(newest))
+            merged.push(newest);
     }
-    return logs;
+    return merged.reverse();
+}
+export function getLogsByOp(opId, limit = Infinity) {
+    const buffer = this.opLogBuffers.get(opId) || [];
+    return buffer.length > limit ? buffer.slice(-limit) : buffer;
+}
+export function getLogsByGroup(group, limit = Infinity) {
+    return mergeRecent(Array.from(this.opLogBuffers.values()), limit, (log) => log.group === group);
 }
-export function getAllLogs() {
-    return Array.from(this.opLogBuffers.values()).flat();
+export function getAllLogs(limit = Infinity) {
+    const buffers = Array.from(this.opLogBuffers.values());
+    // Nothing to interleave, so the buffer already is the answer.
+    const only = buffers.length === 1 ? buffers[0] : undefined;
+    if (only)
+        return only.length > limit ? only.slice(-limit) : only;
+    return mergeRecent(buffers, limit);
 }
 export function subscribe(ws, matcher) {
     this.subscribers.add(ws);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.68-rc",
+  "version": "1.1.69-rc",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@nosana/node",
-      "version": "1.1.68-rc",
+      "version": "1.1.69-rc",
       "license": "ISC",
       "dependencies": {
         "@coral-xyz/anchor": "^0.28.1-beta.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.68-rc",
+  "version": "1.1.69-rc",
   "description": "",
   "bin": {
     "nosana-node": "./dist/src/index.js"