querysub 0.145.0 → 0.147.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.145.0",
+  "version": "0.147.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -24,7 +24,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "preact": "^10.11.3",
-    "socket-function": "^0.81.0",
+    "socket-function": "^0.82.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.6.3",
     "yaml": "^2.5.0",

package/src/0-path-value-core/PathValueCommitter.ts

@@ -291,6 +291,10 @@ class PathValueCommitter {
                         paths.add(hash);
                     }
                 }
+
+                // TODO: Ugh... rejections on initialSync might the wrong solution. I think we have to just remove the values,
+                //  even though this makes debugging harder, in order to prevent the rejections from sticking around.
+
                 for (let batch of batched) {
                     if (!batch.initialTrigger) continue;
                     for (let pathValue of batch.pathValues) {

package/src/4-deploy/edgeBootstrap.ts

@@ -367,8 +367,8 @@ async function edgeNodeFunction(config: {
         let PARALLEL_FACTOR = 3;
         for (let i = 0; i < edgeNodes.length; i += PARALLEL_FACTOR) {
             let node = await new Promise<EdgeNodeConfig | undefined>(resolve => {
+                let finished = 0;
                 for (let j = 0; j < PARALLEL_FACTOR; j++) {
-                    let finished = 0;
                     ((async () => {
                         try {
                             let node = edgeNodes[i + j];

package/src/4-querysub/querysubPrediction.ts

@@ -422,11 +422,6 @@ function predictCall(config: {
     logErrors(predictPromise);
 
     let didCancel = false;
-    // ALWAYS reject the prediction eventually, in case the function runner server is down.
-    //  - ALSO, once it goes back up, the write will be too far in the future, and our lock won't be rejected.
-    //      And don't really want endTime to be infinitely in the future, as then cleanup code has a harder time
-    //      removing the lock, as then in theory it can always be rejected, no matter how long we wait.
-    setTimeout(rejectPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
     function rejectPrediction() {
         if (didCancel) return;
         didCancel = true;
@@ -439,9 +434,18 @@ function predictCall(config: {
             reason: "prediction timeout rejected",
         }]);
     }
-    setTimeout(auditPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
-    function auditPrediction() {
+
+    setTimeout(cleanupPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
+    function cleanupPrediction() {
         if (didCancel) return;
+
+        // ALWAYS reject the prediction, in case the function runner server is down.
+        //  - ALSO, once it goes back up, the write likely will be too far in the future, so our lock won't be rejected,
+        //      will will cause the bad value to stick around.
+        //      We could fix this with an endTime infinitely in the future, but then the lock can never be GCed,
+        //      which create a memory leak.
+        rejectPrediction();
+
         if (Querysub.AUDIT_PREDICTIONS && predictions) {
             const afterTime = { time: call.runAtTime.time, version: Number.MAX_SAFE_INTEGER, creatorId: 0 };
             // Clone predictions, to strip symbols

package/src/diagnostics/ActionsHistory.ts

@@ -33,24 +33,30 @@ export class ActionsHistory {
     }
     public static OnRead(values: PathValue[]) {
         if (ClientWatcher.DEBUG_READS && values.length > 0) {
-            let now = Date.now();
-            let oldest = Math.min(...values.map(x => x.time.time).filter(x => x), now);
-            group(ClientWatcher.DEBUG_READS_EXPANDED)(`(${now - epoch}ms, ${now}) Read count ${values.length}, ${(Date.now() - oldest).toFixed()}ms old`);
-            for (let value of values) {
-                console.log(blue(debugPathValuePath(value)), "===", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
+            values = values.filter(x => !x.path.startsWith(LOCAL_DOMAIN_PATH));
+            if (values.length > 0) {
+                let now = Date.now();
+                let oldest = Math.min(...values.map(x => x.time.time).filter(x => x), now);
+                group(ClientWatcher.DEBUG_READS_EXPANDED)(`(${now - epoch}ms, ${now}) Read count ${values.length}, ${(Date.now() - oldest).toFixed()}ms old`);
+                for (let value of values) {
+                    console.log(blue(debugPathValuePath(value)), "===", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
+                }
+                console.groupEnd();
             }
-            console.groupEnd();
         }
         if (!ActionsHistory.LOG_ACTION_HISTORY) return;
     }
     public static OnWrite(values: PathValue[]) {
         if (ClientWatcher.DEBUG_WRITES) {
-            let now = Date.now();
-            group(ClientWatcher.DEBUG_WRITES_EXPANDED)(green(`(${now - epoch}ms, ${now}) Committing writes ${values.length}`));
-            for (let value of values) {
-                console.log(green(debugPathValuePath(value)), "=", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
+            values = values.filter(x => !x.path.startsWith(LOCAL_DOMAIN_PATH));
+            if (values.length > 0) {
+                let now = Date.now();
+                group(ClientWatcher.DEBUG_WRITES_EXPANDED)(green(`(${now - epoch}ms, ${now}) Committing writes ${values.length}`));
+                for (let value of values) {
+                    console.log(green(debugPathValuePath(value)), "=", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
+                }
+                console.groupEnd();
             }
-            console.groupEnd();
         }
         if (!ActionsHistory.LOG_ACTION_HISTORY) return;
     }