cojson 0.9.10 → 0.9.11

package/src/storage/index.ts

@@ -2,6 +2,7 @@ import { CoID, RawCoValue } from "../coValue.js";
 import { CoValueHeader, Transaction } from "../coValueCore.js";
 import { Signature } from "../crypto/crypto.js";
 import { RawCoID } from "../ids.js";
+import { logger } from "../logger.js";
 import { connectedPeers } from "../streamUtils.js";
 import {
   CoValueKnownState,
@@ -68,7 +69,6 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
 
     const processMessages = async () => {
       for await (const msg of fromLocalNode) {
-        console.log("Storage msg start", nMsg);
         try {
           if (msg === "Disconnected" || msg === "PingTimeout") {
             throw new Error("Unexpected Disconnected message");
@@ -83,32 +83,29 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
             await this.sendNewContent(msg.id, msg, undefined);
           }
         } catch (e) {
-          console.error(
-            new Error(
-              `Error reading from localNode, handling msg\n\n${JSON.stringify(
-                msg,
-                (k, v) =>
-                  k === "changes" || k === "encryptedChanges"
-                    ? v.slice(0, 20) + "..."
-                    : v,
-              )}`,
-              { cause: e },
-            ),
+          logger.error(
+            `Error reading from localNode, handling msg\n\n${JSON.stringify(
+              msg,
+              (k, v) =>
+                k === "changes" || k === "encryptedChanges"
+                  ? v.slice(0, 20) + "..."
+                  : v,
+            )}`,
+            e,
           );
         }
-        console.log("Storage msg end", nMsg);
         nMsg++;
       }
     };
 
     processMessages().catch((e) =>
-      console.error("Error in processMessages in storage", e),
+      logger.error("Error in processMessages in storage", e),
     );
 
     setTimeout(
       () =>
         this.compact().catch((e) => {
-          console.error("Error while compacting", e);
+          logger.error("Error while compacting", e);
         }),
       20000,
     );
@@ -134,7 +131,7 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
           sessions: {},
           asDependencyOf,
         })
-        .catch((e) => console.error("Error while pushing known", e));
+        .catch((e) => logger.error("Error while pushing known", e));
 
       return;
     }
@@ -190,13 +187,13 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
         ...ourKnown,
         asDependencyOf,
       })
-      .catch((e) => console.error("Error while pushing known", e));
+      .catch((e) => logger.error("Error while pushing known", e));
 
     for (const message of newContentMessages) {
       if (Object.keys(message.new).length === 0) continue;
       this.toLocalNode
         .push(message)
-        .catch((e) => console.error("Error while pushing new content", e));
+        .catch((e) => logger.error("Error while pushing new content", e));
     }
 
     this.coValues[id] = coValue;
@@ -232,20 +229,19 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
 
     if (!coValue) {
       if (newContent.header) {
-        // console.log("Creating in WAL", newContent.id);
         await this.withWAL((wal) =>
           writeToWal(wal, this.fs, newContent.id, newContentAsChunk),
         );
 
         this.coValues[newContent.id] = newContentAsChunk;
       } else {
-        console.warn("Incontiguous incoming update for " + newContent.id);
+        logger.warn("Incontiguous incoming update for " + newContent.id);
         return;
       }
     } else {
       const merged = mergeChunks(coValue, newContentAsChunk);
       if (merged === "nonContigous") {
-        console.warn(
+        logger.warn(
           "Non-contigous new content for " + newContent.id,
           Object.entries(coValue.sessionEntries).map(([session, entries]) =>
             entries.map((entry) => ({
@@ -264,7 +260,6 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
           ),
         );
       } else {
-        // console.log("Appending to WAL", newContent.id);
         await this.withWAL((wal) =>
           writeToWal(wal, this.fs, newContent.id, newContentAsChunk),
         );
@@ -301,8 +296,6 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
 
       const { handle, size } = await this.getBlockHandle(blockFile, fs);
 
-      // console.log("Attempting to load", id, blockFile);
-
       if (!cachedHeader) {
         cachedHeader = {};
         const header = await readHeader(blockFile, handle, size, fs);
@@ -317,15 +310,13 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
       }
       const headerEntry = cachedHeader[id];
 
-      // console.log("Header entry", id, headerEntry);
-
       if (headerEntry) {
         const nextChunk = await readChunk(handle, headerEntry, fs);
         if (result) {
           const merged = mergeChunks(result, nextChunk);
 
           if (merged === "nonContigous") {
-            console.warn(
+            logger.warn(
               "Non-contigous chunks while loading " + id,
               result,
               nextChunk,
@@ -354,7 +345,6 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
 
     const coValues = new Map<RawCoID, CoValueChunk>();
 
-    console.log("Compacting WAL files", walFiles);
     if (walFiles.length === 0) return;
 
     const oldWal = this.currentWal;
@@ -385,7 +375,7 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
         if (existingChunk) {
           const merged = mergeChunks(existingChunk, chunk);
           if (merged === "nonContigous") {
-            console.log(
+            logger.info(
               "Non-contigous chunks in " + chunk.id + ", " + fileName,
               existingChunk,
               chunk,
@@ -411,8 +401,6 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
       return acc;
     }, 0);
 
-    console.log([...coValues.keys()], fileNames, highestBlockNumber);
-
     await writeBlock(coValues, MAX_N_LEVELS, highestBlockNumber + 1, this.fs);
 
     for (const walFile of walFiles) {
@@ -438,15 +426,11 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
       blockFilesByLevelInOrder[level]!.push(blockFile);
     }
 
-    console.log(blockFilesByLevelInOrder);
-
     for (let level = MAX_N_LEVELS; level > 0; level--) {
       const nBlocksDesired = Math.pow(2, level);
       const blocksInLevel = blockFilesByLevelInOrder[level];
 
       if (blocksInLevel && blocksInLevel.length > nBlocksDesired) {
-        console.log("Compacting blocks in level", level, blocksInLevel);
-
         const coValues = new Map<RawCoID, CoValueChunk>();
 
         for (const blockFile of blocksInLevel) {
@@ -465,7 +449,7 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
             if (existingChunk) {
               const merged = mergeChunks(existingChunk, chunk);
               if (merged === "nonContigous") {
-                console.log(
+                logger.info(
                   "Non-contigous chunks in " + entry.id + ", " + blockFile,
                   existingChunk,
                   chunk,
@@ -517,7 +501,7 @@ export class LSMStorage<WH, RH, FS extends FileSystem<WH, RH>> {
     setTimeout(
       () =>
         this.compact().catch((e) => {
-          console.error("Error while compacting", e);
+          logger.error("Error while compacting", e);
         }),
       5000,
     );

package/src/sync.ts

@@ -6,6 +6,7 @@ import { CoValueCore } from "./coValueCore.js";
 import { Signature } from "./crypto/crypto.js";
 import { RawCoID, SessionID } from "./ids.js";
 import { LocalNode } from "./localNode.js";
+import { logger } from "./logger.js";
 import { CoValuePriority } from "./priority.js";
 
 export type CoValueKnownState = {
@@ -150,7 +151,7 @@ export class SyncManager {
 
   async handleSyncMessage(msg: SyncMessage, peer: PeerState) {
     if (peer.erroredCoValues.has(msg.id)) {
-      console.error(
+      logger.warn(
         `Skipping message ${msg.action} on errored coValue ${msg.id} from peer ${peer.id}`,
       );
       return;
@@ -182,7 +183,7 @@ export class SyncManager {
 
     if (entry.state.type !== "available") {
       entry.loadFromPeers([peer]).catch((e: unknown) => {
-        console.error("Error sending load", e);
+        logger.error("Error sending load", e);
       });
       return;
     }
@@ -199,7 +200,7 @@ export class SyncManager {
         action: "load",
         ...coValue.knownState(),
       }).catch((e: unknown) => {
-        console.error("Error sending load", e);
+        logger.error("Error sending load", e);
       });
     }
   }
@@ -229,7 +230,7 @@ export class SyncManager {
         asDependencyOf,
         ...coValue.knownState(),
       }).catch((e: unknown) => {
-        console.error("Error sending known state", e);
+        logger.error("Error sending known state", e);
       });
 
       peer.toldKnownState.add(id);
@@ -256,15 +257,8 @@ export class SyncManager {
       const sendPieces = async () => {
         let lastYield = performance.now();
         for (const [_i, piece] of newContentPieces.entries()) {
-          // console.log(
-          //     `${id} -> ${peer.id}: Sending content piece ${i + 1}/${
-          //         newContentPieces.length
-          //     } header: ${!!piece.header}`,
-          //     // Object.values(piece.new).map((s) => s.newTransactions)
-          // );
-
           this.trySendToPeer(peer, piece).catch((e: unknown) => {
-            console.error("Error sending content piece", e);
+            logger.error("Error sending content piece", e);
           });
 
           if (performance.now() - lastYield > 10) {
@@ -277,7 +271,7 @@ export class SyncManager {
       };
 
       sendPieces().catch((e) => {
-        console.error("Error sending new content piece, retrying", e);
+        logger.error("Error sending new content piece, retrying", e);
         peer.optimisticKnownStates.dispatch({
           type: "SET",
           id,
@@ -337,7 +331,7 @@ export class SyncManager {
           return;
         }
         if (msg === "PingTimeout") {
-          console.error("Ping timeout from peer", peer.id);
+          logger.error("Ping timeout from peer", peer.id);
           return;
         }
         try {
@@ -360,13 +354,13 @@ export class SyncManager {
     processMessages()
       .then(() => {
         if (peer.crashOnClose) {
-          console.error("Unexepcted close from peer", peer.id);
+          logger.warn("Unexepcted close from peer", peer.id);
           this.local.crashed = new Error("Unexpected close from peer");
           throw new Error("Unexpected close from peer");
         }
       })
       .catch((e) => {
-        console.error("Error processing messages from peer", peer.id, e);
+        logger.error("Error processing messages from peer", peer.id, e);
         if (peer.crashOnClose) {
           this.local.crashed = e;
           throw new Error(e);
@@ -406,13 +400,13 @@ export class SyncManager {
         // where we can get informations about the coValue
         if (msg.header || Object.keys(msg.sessions).length > 0) {
           entry.loadFromPeers([peer]).catch((e) => {
-            console.error("Error loading coValue in handleLoad", e);
+            logger.error("Error loading coValue in handleLoad", e);
           });
         }
         return;
       } else {
         this.local.loadCoValueCore(msg.id, peer.id).catch((e) => {
-          console.error("Error loading coValue in handleLoad", e);
+          logger.error("Error loading coValue in handleLoad", e);
         });
       }
     }
@@ -439,7 +433,7 @@ export class SyncManager {
               header: false,
               sessions: {},
             }).catch((e) => {
-              console.error("Error sending known state back", e);
+              logger.error("Error sending known state back", e);
             });
 
             return;
@@ -449,7 +443,7 @@ export class SyncManager {
           await this.sendNewContentIncludingDependencies(msg.id, peer);
         })
         .catch((e) => {
-          console.error("Error loading coValue in handleLoad loading state", e);
+          logger.error("Error loading coValue in handleLoad loading state", e);
         });
     }
 
@@ -484,7 +478,7 @@ export class SyncManager {
               peer.role === "storage" ? undefined : peer.id,
             )
             .catch((e) => {
-              console.error(
+              logger.error(
                 `Error loading coValue ${msg.id} to create loading state, as dependency of ${msg.asDependencyOf}`,
                 e,
               );
@@ -521,7 +515,7 @@ export class SyncManager {
 
     if (entry.state.type !== "available") {
       if (!msg.header) {
-        console.error("Expected header to be sent in first message");
+        logger.error("Expected header to be sent in first message");
         return;
       }
 
@@ -584,7 +578,7 @@ export class SyncManager {
               : t.changes.length,
           )
           .reduce((a, b) => a + b, 0);
-        console.log(
+        logger.debug(
           `Adding incoming transactions took ${(after - before).toFixed(
             2,
           )}ms for ${totalTxLength} bytes = bandwidth: ${(
@@ -602,7 +596,7 @@ export class SyncManager {
       // );
 
       if (result.isErr()) {
-        console.error(
+        logger.error(
           "Failed to add transactions from",
           peer.id,
           result.error,
@@ -633,7 +627,7 @@ export class SyncManager {
         isCorrection: true,
         ...coValue.knownState(),
       }).catch((e) => {
-        console.error("Error sending known state correction", e);
+        logger.error("Error sending known state correction", e);
       });
     } else {
       /**
@@ -647,7 +641,7 @@ export class SyncManager {
         action: "known",
         ...coValue.knownState(),
       }).catch((e: unknown) => {
-        console.error("Error sending known state", e);
+        logger.error("Error sending known state", e);
       });
     }
 
@@ -681,9 +675,6 @@ export class SyncManager {
       const done = new Promise<void>((resolve) => {
         queueMicrotask(async () => {
           delete this.requestedSyncs[coValue.id];
-          // if (entry.nRequestsThisTick >= 2) {
-          //     console.log("Syncing", coValue.id, "for", entry.nRequestsThisTick, "requests");
-          // }
           await this.actuallySyncCoValue(coValue);
           resolve();
         });

package/src/tests/PeerState.test.ts

@@ -49,12 +49,9 @@ describe("PeerState", () => {
 
   test("should perform graceful shutdown", () => {
     const { mockPeer, peerState } = setup();
-    const consoleSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
     peerState.gracefulShutdown();
     expect(mockPeer.outgoing.close).toHaveBeenCalled();
     expect(peerState.closed).toBe(true);
-    expect(consoleSpy).toHaveBeenCalledWith("Gracefully closing", "test-peer");
-    consoleSpy.mockRestore();
   });
 
   test("should empty the queue when closing", async () => {

package/src/tests/PriorityBasedMessageQueue.test.ts

@@ -22,7 +22,7 @@ describe("PriorityBasedMessageQueue", () => {
     const { queue } = setup();
     expect(queue["defaultPriority"]).toBe(CO_VALUE_PRIORITY.MEDIUM);
     expect(queue["queues"].length).toBe(8);
-    expect(queue["queues"].every((q) => q.length === 0)).toBe(true);
+    expect(queue["queues"].every((q) => !q.isNonEmpty())).toBe(true);
   });
 
   test("should push message with default priority", async () => {

package/src/tests/logger.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test, vi } from "vitest";
+import { LogLevel, Logger } from "../logger";
+
+describe("Logger", () => {
+  describe("Log Level Filtering", () => {
+    test("should respect log level hierarchy", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.WARN, mockLogSystem);
+
+      logger.debug("Debug message");
+      logger.info("Info message");
+      logger.warn("Warning message");
+      logger.error("Error message");
+
+      expect(mockLogSystem.debug).not.toHaveBeenCalled();
+      expect(mockLogSystem.info).not.toHaveBeenCalled();
+      expect(mockLogSystem.warn).toHaveBeenCalledWith("Warning message");
+      expect(mockLogSystem.error).toHaveBeenCalledWith("Error message");
+    });
+
+    test("should pass additional arguments to log system", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.DEBUG, mockLogSystem);
+      const additionalArgs = [{ foo: "bar" }, 42, "extra"];
+
+      logger.debug("Debug message", ...additionalArgs);
+
+      expect(mockLogSystem.debug).toHaveBeenCalledWith(
+        "Debug message",
+        ...additionalArgs,
+      );
+    });
+  });
+
+  describe("Log System Configuration", () => {
+    test("should allow changing log level at runtime", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.ERROR, mockLogSystem);
+
+      logger.warn("Warning 1"); // Should not log
+      expect(mockLogSystem.warn).not.toHaveBeenCalled();
+
+      logger.setLevel(LogLevel.WARN);
+      logger.warn("Warning 2"); // Should log
+      expect(mockLogSystem.warn).toHaveBeenCalledWith("Warning 2");
+    });
+
+    test("should allow changing log system at runtime", () => {
+      const mockLogSystem1 = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const mockLogSystem2 = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.INFO, mockLogSystem1);
+
+      logger.info("Message 1");
+      expect(mockLogSystem1.info).toHaveBeenCalledWith("Message 1");
+      expect(mockLogSystem2.info).not.toHaveBeenCalled();
+
+      logger.setLogSystem(mockLogSystem2);
+      logger.info("Message 2");
+      expect(mockLogSystem2.info).toHaveBeenCalledWith("Message 2");
+      expect(mockLogSystem1.info).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("Default Console Log System", () => {
+    test("should use console methods by default", () => {
+      const consoleSpy = {
+        debug: vi.spyOn(console, "debug").mockImplementation(() => {}),
+        info: vi.spyOn(console, "info").mockImplementation(() => {}),
+        warn: vi.spyOn(console, "warn").mockImplementation(() => {}),
+        error: vi.spyOn(console, "error").mockImplementation(() => {}),
+      };
+
+      const logger = new Logger();
+      logger.setLevel(LogLevel.DEBUG);
+      const testMessage = "Test message";
+      const testArgs = [{ data: "test" }, 123];
+
+      logger.debug(testMessage, ...testArgs);
+      logger.info(testMessage, ...testArgs);
+      logger.warn(testMessage, ...testArgs);
+      logger.error(testMessage, ...testArgs);
+
+      expect(consoleSpy.debug).toHaveBeenCalledWith(testMessage, ...testArgs);
+      expect(consoleSpy.info).toHaveBeenCalledWith(testMessage, ...testArgs);
+      expect(consoleSpy.warn).toHaveBeenCalledWith(testMessage, ...testArgs);
+      expect(consoleSpy.error).toHaveBeenCalledWith(testMessage, ...testArgs);
+
+      // Cleanup
+      Object.values(consoleSpy).forEach((spy) => spy.mockRestore());
+    });
+  });
+
+  describe("Log Level NONE", () => {
+    test("should not log anything when level is NONE", () => {
+      const mockLogSystem = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const logger = new Logger(LogLevel.NONE, mockLogSystem);
+
+      logger.debug("Debug message");
+      logger.info("Info message");
+      logger.warn("Warning message");
+      logger.error("Error message");
+
+      expect(mockLogSystem.debug).not.toHaveBeenCalled();
+      expect(mockLogSystem.info).not.toHaveBeenCalled();
+      expect(mockLogSystem.warn).not.toHaveBeenCalled();
+      expect(mockLogSystem.error).not.toHaveBeenCalled();
+    });
+  });
+});