From 9895c918810e90976f3990d9b74fe5edf478d784 Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Tue, 8 Apr 2025 10:18:43 +0200
Subject: [PATCH 1/8] Updated BroadcastLogger to respect logLevels. Passing log
 level to db and sync worker.

---
 .../adapters/wa-sqlite/WASQLiteOpenFactory.ts | 11 ++++--
 .../SharedWebStreamingSyncImplementation.ts   |  2 ++
 .../db/sync/WebStreamingSyncImplementation.ts |  5 ++-
 .../web/src/worker/db/WASQLiteDB.worker.ts    | 22 ++++++++----
 .../web/src/worker/sync/BroadcastLogger.ts    | 35 ++++++++++++++++---
 .../worker/sync/SharedSyncImplementation.ts   | 11 ++++--
 6 files changed, 69 insertions(+), 17 deletions(-)

diff --git a/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts b/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts
index 6217b35d..95589f87 100644
--- a/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts
+++ b/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts
@@ -12,6 +12,7 @@ import {
 } from '../web-sql-flags';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
 import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
+import { ILogLevel } from 'js-logger';
 
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
   vfs?: WASQLiteVFS;
@@ -20,6 +21,11 @@ export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
 export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
   vfs: WASQLiteVFS;
 }
+
+export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
+  logLevel: ILogLevel;
+}
+
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
@@ -73,7 +79,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
             )
           : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
 
-      const workerDBOpener = Comlink.wrap<OpenAsyncDatabaseConnection<ResolvedWASQLiteOpenFactoryOptions>>(workerPort);
+      const workerDBOpener = Comlink.wrap<OpenAsyncDatabaseConnection<WorkerDBOpenerOptions>>(workerPort);
 
       return new WorkerWrappedAsyncDatabaseConnection({
         remote: workerDBOpener,
@@ -83,7 +89,8 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
           temporaryStorage,
           cacheSizeKb,
           flags: this.resolvedFlags,
-          encryptionKey: encryptionKey
+          encryptionKey: encryptionKey,
+          logLevel: this.logger.getLevel()
         }),
         identifier: this.options.dbFilename,
         onClose: () => {
diff --git a/packages/web/src/db/sync/SharedWebStreamingSyncImplementation.ts b/packages/web/src/db/sync/SharedWebStreamingSyncImplementation.ts
index 916541d9..dadb1276 100644
--- a/packages/web/src/db/sync/SharedWebStreamingSyncImplementation.ts
+++ b/packages/web/src/db/sync/SharedWebStreamingSyncImplementation.ts
@@ -135,6 +135,8 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     }
 
     this.syncManager = Comlink.wrap<SharedSyncImplementation>(this.messagePort);
+    this.syncManager.setLogLevel(this.logger.getLevel());
+
     this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
 
     /**
diff --git a/packages/web/src/db/sync/WebStreamingSyncImplementation.ts b/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
index 05d60f0a..9d55c3a7 100644
--- a/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
+++ b/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
@@ -6,6 +6,7 @@ import {
 } from '@powersync/common';
 import { getNavigatorLocks } from '../../shared/navigator';
 import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags';
+import Logger from 'js-logger';
 
 export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
   flags?: WebSQLFlags;
@@ -26,7 +27,9 @@ export class WebStreamingSyncImplementation extends AbstractStreamingSyncImpleme
 
   obtainLock<T>(lockOptions: LockOptions<T>): Promise<T> {
     const identifier = `streaming-sync-${lockOptions.type}-${this.webOptions.identifier}`;
-    lockOptions.type == LockType.SYNC && console.debug('requesting lock for ', identifier);
+    if (lockOptions.type == LockType.SYNC) {
+      (this.logger ?? Logger.get('WebStreamingSyncImplementation')).debug('requesting lock for ', identifier);
+    }
     return getNavigatorLocks().request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
   }
 }
diff --git a/packages/web/src/worker/db/WASQLiteDB.worker.ts b/packages/web/src/worker/db/WASQLiteDB.worker.ts
index 7e28b024..c7ac24ec 100644
--- a/packages/web/src/worker/db/WASQLiteDB.worker.ts
+++ b/packages/web/src/worker/db/WASQLiteDB.worker.ts
@@ -6,8 +6,15 @@ import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
 import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
 import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
-import { ResolvedWASQLiteOpenFactoryOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
+import {
+  ResolvedWASQLiteOpenFactoryOptions,
+  WorkerDBOpenerOptions
+} from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
 import { getNavigatorLocks } from '../../shared/navigator';
+import Logger from 'js-logger';
+
+Logger.useDefaults();
+const logger = Logger.get('db-worker');
 
 /**
  * Keeps track of open DB connections and the clients which
@@ -39,11 +46,14 @@ const openWorkerConnection = async (options: ResolvedWASQLiteOpenFactoryOptions)
   };
 };
 
-const openDBShared = async (options: ResolvedWASQLiteOpenFactoryOptions): Promise<AsyncDatabaseConnection> => {
+const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {
   // Prevent multiple simultaneous opens from causing race conditions
   return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
     const clientId = nextClientId++;
-    const { dbFilename } = options;
+    const { dbFilename, logLevel } = options;
+
+    logger.setLevel(logLevel);
+
     if (!DBMap.has(dbFilename)) {
       const clientIds = new Set<number>();
       const connection = await openWorkerConnection(options);
@@ -65,14 +75,14 @@ const openDBShared = async (options: ResolvedWASQLiteOpenFactoryOptions): Promis
       }),
       close: Comlink.proxy(() => {
         const { clientIds } = dbEntry;
-        console.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
+        logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
         clientIds.delete(clientId);
         if (clientIds.size == 0) {
-          console.debug(`Closing connection to ${dbFilename}.`);
+          logger.debug(`Closing connection to ${dbFilename}.`);
           DBMap.delete(dbFilename);
           return db.close?.();
         }
-        console.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+        logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
         return;
       })
     };
diff --git a/packages/web/src/worker/sync/BroadcastLogger.ts b/packages/web/src/worker/sync/BroadcastLogger.ts
index 099f65d7..0b1bbb3c 100644
--- a/packages/web/src/worker/sync/BroadcastLogger.ts
+++ b/packages/web/src/worker/sync/BroadcastLogger.ts
@@ -13,6 +13,8 @@ export class BroadcastLogger implements ILogger {
   ERROR: ILogLevel;
   OFF: ILogLevel;
 
+  private currentLevel: ILogLevel = Logger.INFO;
+
   constructor(protected clients: WrappedSyncPort[]) {
     this.TRACE = Logger.TRACE;
     this.DEBUG = Logger.DEBUG;
@@ -24,63 +26,86 @@ export class BroadcastLogger implements ILogger {
   }
 
   trace(...x: any[]): void {
+    if (!this.enabledFor(this.TRACE)) return;
+
     console.trace(...x);
     const sanitized = this.sanitizeArgs(x);
     this.iterateClients((client) => client.clientProvider.trace(...sanitized));
   }
 
   debug(...x: any[]): void {
+    if (!this.enabledFor(this.DEBUG)) return;
+
     console.debug(...x);
     const sanitized = this.sanitizeArgs(x);
     this.iterateClients((client) => client.clientProvider.debug(...sanitized));
   }
 
   info(...x: any[]): void {
+    if (!this.enabledFor(this.INFO)) return;
+
     console.info(...x);
     const sanitized = this.sanitizeArgs(x);
     this.iterateClients((client) => client.clientProvider.info(...sanitized));
   }
 
   log(...x: any[]): void {
+    if (!this.enabledFor(this.INFO)) return;
+
     console.log(...x);
     const sanitized = this.sanitizeArgs(x);
     this.iterateClients((client) => client.clientProvider.log(...sanitized));
   }
 
   warn(...x: any[]): void {
+    if (!this.enabledFor(this.WARN)) return;
+
     console.warn(...x);
     const sanitized = this.sanitizeArgs(x);
     this.iterateClients((client) => client.clientProvider.warn(...sanitized));
   }
 
   error(...x: any[]): void {
+    if (!this.enabledFor(this.ERROR)) return;
+
     console.error(...x);
     const sanitized = this.sanitizeArgs(x);
     this.iterateClients((client) => client.clientProvider.error(...sanitized));
   }
 
   time(label: string): void {
+    if (!this.enabledFor(this.TIME)) return;
+
     console.time(label);
     this.iterateClients((client) => client.clientProvider.time(label));
   }
 
   timeEnd(label: string): void {
+    if (!this.enabledFor(this.TIME)) return;
+
     console.timeEnd(label);
     this.iterateClients((client) => client.clientProvider.timeEnd(label));
   }
 
+  /**
+   * Set the global log level.
+   */
   setLevel(level: ILogLevel): void {
-    // Levels are not adjustable on this level.
+    this.currentLevel = level;
   }
 
+  /**
+   * Get the current log level.
+   */
   getLevel(): ILogLevel {
-    // Levels are not adjustable on this level.
-    return Logger.INFO;
+    return this.currentLevel;
   }
 
+  /**
+   * Returns true if the given level is enabled.
+   */
   enabledFor(level: ILogLevel): boolean {
-    // Levels are not adjustable on this level.
-    return true;
+    return level.value >= this.currentLevel.value;
   }
 
   /**
diff --git a/packages/web/src/worker/sync/SharedSyncImplementation.ts b/packages/web/src/worker/sync/SharedSyncImplementation.ts
index f5c7c5bd..d9713933 100644
--- a/packages/web/src/worker/sync/SharedSyncImplementation.ts
+++ b/packages/web/src/worker/sync/SharedSyncImplementation.ts
@@ -13,7 +13,7 @@ import {
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
-import Logger, { type ILogger } from 'js-logger';
+import Logger, { ILogLevel, type ILogger } from 'js-logger';
 import { WebRemote } from '../../db/sync/WebRemote';
 import {
   WebStreamingSyncImplementation,
@@ -145,6 +145,11 @@ export class SharedSyncImplementation
     return this.isInitialized;
   }
 
+  setLogLevel(level: ILogLevel) {
+    this.logger.setLevel(level);
+    this.broadCastLogger.setLevel(level);
+  }
+
   /**
    * Configures the DBAdapter connection and a streaming sync client.
    */
@@ -234,7 +239,7 @@ export class SharedSyncImplementation
   async removePort(port: MessagePort) {
     const index = this.ports.findIndex((p) => p.port == port);
     if (index < 0) {
-      console.warn(`Could not remove port ${port} since it is not present in active ports.`);
+      this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
       return;
     }
 
@@ -311,7 +316,7 @@ export class SharedSyncImplementation
 
             abortController.signal.onabort = reject;
             try {
-              console.log('calling the last port client provider for credentials');
+              this.logger.log('calling the last port client provider for credentials');
               resolve(await lastPort.clientProvider.fetchCredentials());
             } catch (ex) {
               reject(ex);

From 4d6e73b7477a5c294a5e59630a8b48b92d5ccf53 Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Tue, 8 Apr 2025 11:41:52 +0200
Subject: [PATCH 2/8] Exposing logger in AbstractPowerSyncDatabase, opens the
 ability to have controlled logging in packages like Attachments, React, and
 Vue.

---
 .../src/AbstractAttachmentQueue.ts            | 42 ++++++++++---------
 .../src/client/AbstractPowerSyncDatabase.ts   | 34 ++++++++-------
 packages/react/src/WatchedQuery.ts            |  8 +++-
 packages/react/src/hooks/useQuery.ts          |  7 ++--
 packages/vue/src/composables/useQuery.ts      |  7 ++--
 .../db/adapters/AbstractWebSQLOpenFactory.ts  |  4 +-
 6 files changed, 58 insertions(+), 44 deletions(-)

diff --git a/packages/attachments/src/AbstractAttachmentQueue.ts b/packages/attachments/src/AbstractAttachmentQueue.ts
index 888d38a5..a5f4d4d2 100644
--- a/packages/attachments/src/AbstractAttachmentQueue.ts
+++ b/packages/attachments/src/AbstractAttachmentQueue.ts
@@ -91,6 +91,10 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
     return this.options.powersync;
   }
 
+  get logger() {
+    return this.powersync.logger;
+  }
+
   protected get storage() {
     return this.options.storage;
   }
@@ -123,7 +127,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
   async watchAttachmentIds() {
     this.onAttachmentIdsChange(async (ids) => {
       const _ids = `${ids.map((id) => `'${id}'`).join(',')}`;
-      console.debug(`Queuing for sync, attachment IDs: [${_ids}]`);
+      this.logger.debug(`Queuing for sync, attachment IDs: [${_ids}]`);
 
       if (this.initialSync) {
         this.initialSync = false;
@@ -151,11 +155,11 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
             id: id,
             state: AttachmentState.QUEUED_SYNC
           });
-          console.debug(`Attachment (${id}) not found in database, creating new record`);
+          this.logger.debug(`Attachment (${id}) not found in database, creating new record`);
           await this.saveToQueue(newRecord);
         } else if (record.local_uri == null || !(await this.storage.fileExists(this.getLocalUri(record.local_uri)))) {
           // 2. Attachment in database but no local file, mark as queued download
-          console.debug(`Attachment (${id}) found in database but no local file, marking as queued download`);
+          this.logger.debug(`Attachment (${id}) found in database but no local file, marking as queued download`);
           await this.update({
             ...record,
             state: AttachmentState.QUEUED_DOWNLOAD
@@ -241,7 +245,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
         filename: record.filename
       });
     } catch (e) {
-      console.error(e);
+      this.logger.error(e);
     }
   }
 
@@ -267,7 +271,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
     const localFilePathUri = this.getLocalUri(record.local_uri);
     try {
       if (!(await this.storage.fileExists(localFilePathUri))) {
-        console.warn(`File for ${record.id} does not exist, skipping upload`);
+        this.logger.warn(`File for ${record.id} does not exist, skipping upload`);
         await this.update({
           ...record,
           state: AttachmentState.QUEUED_DOWNLOAD
@@ -285,11 +289,11 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
       });
       // Mark as uploaded
       await this.update({ ...record, state: AttachmentState.SYNCED });
-      console.debug(`Uploaded attachment "${record.id}" to Cloud Storage`);
+      this.logger.debug(`Uploaded attachment "${record.id}" to Cloud Storage`);
       return true;
     } catch (e: any) {
       if (e.error == 'Duplicate') {
-        console.debug(`File already uploaded, marking ${record.id} as synced`);
+        this.logger.debug(`File already uploaded, marking ${record.id} as synced`);
         await this.update({ ...record, state: AttachmentState.SYNCED });
         return false;
       }
@@ -300,7 +304,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
           return true;
         }
       }
-      console.error(`UploadAttachment error for record ${JSON.stringify(record, null, 2)}`);
+      this.logger.error(`UploadAttachment error for record ${JSON.stringify(record, null, 2)}`);
       return false;
     }
   }
@@ -314,7 +318,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
     }
     const localFilePathUri = this.getLocalUri(record.local_uri);
     if (await this.storage.fileExists(localFilePathUri)) {
-      console.debug(`Local file already downloaded, marking "${record.id}" as synced`);
+      this.logger.debug(`Local file already downloaded, marking "${record.id}" as synced`);
       await this.update({ ...record, state: AttachmentState.SYNCED });
       return true;
     }
@@ -345,7 +349,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
         media_type: fileBlob.type,
         state: AttachmentState.SYNCED
       });
-      console.debug(`Downloaded attachment "${record.id}"`);
+      this.logger.debug(`Downloaded attachment "${record.id}"`);
       return true;
     } catch (e) {
       if (this.options.onDownloadError) {
@@ -355,7 +359,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
           return true;
         }
       }
-      console.error(`Download attachment error for record ${JSON.stringify(record, null, 2)}`, e);
+      this.logger.error(`Download attachment error for record ${JSON.stringify(record, null, 2)}`, e);
     }
     return false;
   }
@@ -396,7 +400,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
       if (!record) {
         return;
       }
-      console.debug(`Uploading attachments...`);
+      this.logger.debug(`Uploading attachments...`);
       while (record) {
         const uploaded = await this.uploadAttachment(record);
         if (!uploaded) {
@@ -405,9 +409,9 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
         }
         record = await this.getNextUploadRecord();
       }
-      console.debug('Finished uploading attachments');
+      this.logger.debug('Finished uploading attachments');
     } catch (error) {
-      console.error('Upload failed:', error);
+      this.logger.error('Upload failed:', error);
     } finally {
       this.uploading = false;
     }
@@ -464,7 +468,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
 
     this.downloading = true;
     try {
-      console.debug(`Downloading ${this.downloadQueue.size} attachments...`);
+      this.logger.debug(`Downloading ${this.downloadQueue.size} attachments...`);
       while (this.downloadQueue.size > 0) {
         const id = this.downloadQueue.values().next().value;
         this.downloadQueue.delete(id);
@@ -474,9 +478,9 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
         }
         await this.downloadRecord(record);
       }
-      console.debug('Finished downloading attachments');
+      this.logger.debug('Finished downloading attachments');
     } catch (e) {
-      console.error('Downloads failed:', e);
+      this.logger.error('Downloads failed:', e);
     } finally {
       this.downloading = false;
     }
@@ -518,7 +522,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
       return;
     }
 
-    console.debug(`Deleting ${res.length} attachments from cache...`);
+    this.logger.debug(`Deleting ${res.length} attachments from cache...`);
     await this.powersync.writeTransaction(async (tx) => {
       for (const record of res) {
         await this.delete(record, tx);
@@ -527,7 +531,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
   }
 
   async clearQueue(): Promise<void> {
-    console.debug(`Clearing attachment queue...`);
+    this.logger.debug(`Clearing attachment queue...`);
     await this.powersync.writeTransaction(async (tx) => {
       await tx.execute(`DELETE FROM ${this.table}`);
     });
diff --git a/packages/common/src/client/AbstractPowerSyncDatabase.ts b/packages/common/src/client/AbstractPowerSyncDatabase.ts
index 2e71083e..c5650735 100644
--- a/packages/common/src/client/AbstractPowerSyncDatabase.ts
+++ b/packages/common/src/client/AbstractPowerSyncDatabase.ts
@@ -406,6 +406,10 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
     this.iterateListeners(async (cb) => cb.schemaChanged?.(schema));
   }
 
+  get logger() {
+    return this.options.logger!;
+  }
+
   /**
    * Wait for initialization to complete.
    * While initializing is automatic, this helps to catch and report initialization errors.
@@ -555,7 +559,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * This method does include transaction ids in the result, but does not group
    * data by transaction. One batch may contain data from multiple transactions,
    * and a single transaction may be split over multiple batches.
-   * 
+   *
    * @param limit Maximum number of CRUD entries to include in the batch
    * @returns A batch of CRUD operations to upload, or null if there are none
    */
@@ -594,7 +598,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    *
    * Unlike {@link getCrudBatch}, this only returns data from a single transaction at a time.
    * All data for the transaction is loaded into memory.
-   * 
+   *
    * @returns A transaction of CRUD operations to upload, or null if there are none
    */
   async getNextCrudTransaction(): Promise<CrudTransaction | null> {
@@ -633,7 +637,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Get an unique client id for this database.
    *
    * The id is not reset when the database is cleared, only when the database is deleted.
-   * 
+   *
    * @returns A unique identifier for the database instance
    */
   async getClientId(): Promise<string> {
@@ -661,7 +665,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   /**
    * Execute a SQL write (INSERT/UPDATE/DELETE) query
    * and optionally return results.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @returns The query result as an object with structured key-value pairs
@@ -674,7 +678,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   /**
    * Execute a SQL write (INSERT/UPDATE/DELETE) query directly on the database without any PowerSync processing.
    * This bypasses certain PowerSync abstractions and is useful for accessing the raw database results.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @returns The raw query result from the underlying database as a nested array of raw values, where each row is
@@ -689,7 +693,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Execute a write query (INSERT/UPDATE/DELETE) multiple times with each parameter set
    * and optionally return results.
    * This is faster than executing separately with each parameter set.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional 2D array of parameter sets, where each inner array is a set of parameters for one execution
    * @returns The query result
@@ -701,7 +705,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
   /**
    *  Execute a read-only query and return results.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @returns An array of results
@@ -713,7 +717,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
   /**
    * Execute a read-only query and return the first result, or null if the ResultSet is empty.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @returns The first result if found, or null if no results are returned
@@ -725,7 +729,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
 
   /**
    * Execute a read-only query and return the first result, error if the ResultSet is empty.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @returns The first result matching the query
@@ -761,7 +765,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Open a read-only transaction.
    * Read transactions can run concurrently to a write transaction.
    * Changes from any write transaction are not visible to read transactions started before it.
-   * 
+   *
    * @param callback Function to execute within the transaction
    * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
    * @returns The result of the callback
@@ -786,7 +790,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Open a read-write transaction.
    * This takes a global lock - only one write transaction can execute against the database at a time.
    * Statements within the transaction must be done on the provided {@link Transaction} interface.
-   * 
+   *
    * @param callback Function to execute within the transaction
    * @param lockTimeout Time in milliseconds to wait for a lock before throwing an error
    * @returns The result of the callback
@@ -865,7 +869,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
    *
    * Note that the `onChange` callback member of the handler is required.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @param handler Callbacks for handling results and errors
@@ -915,7 +919,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Execute a read query every time the source tables are modified.
    * Use {@link SQLWatchOptions.throttleMs} to specify the minimum interval between queries.
    * Source tables are automatically detected using `EXPLAIN QUERY PLAN`.
-   * 
+   *
    * @param sql The SQL query to execute
    * @param parameters Optional array of parameters to bind to the query
    * @param options Options for configuring watch behavior
@@ -944,7 +948,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    * Resolves the list of tables that are used in a SQL query.
    * If tables are specified in the options, those are used directly.
    * Otherwise, analyzes the query using EXPLAIN to determine which tables are accessed.
-   * 
+   *
    * @param sql The SQL query to analyze
    * @param parameters Optional parameters for the SQL query
    * @param options Optional watch options that may contain explicit table list
@@ -1077,7 +1081,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
    *
    * This is preferred over {@link watchWithAsyncGenerator} when multiple queries need to be performed
    * together when data is changed.
-   * 
+   *
    * Note: do not declare this as `async *onChange` as it will not work in React Native.
    *
    * @param options Options for configuring watch behavior
diff --git a/packages/react/src/WatchedQuery.ts b/packages/react/src/WatchedQuery.ts
index be52a008..a4a08614 100644
--- a/packages/react/src/WatchedQuery.ts
+++ b/packages/react/src/WatchedQuery.ts
@@ -46,6 +46,10 @@ export class WatchedQuery extends BaseObserver<WatchedQueryListener> implements
     });
   }
 
+  get logger() {
+    return this.db.logger;
+  }
+
   addTemporaryHold() {
     const ref = new Object();
     this.temporaryHolds.add(ref);
@@ -88,7 +92,7 @@ export class WatchedQuery extends BaseObserver<WatchedQueryListener> implements
     try {
       this.tables = await this.db.resolveTables(this.query.sqlStatement, this.query.queryParameters, this.options);
     } catch (e) {
-      console.error('Failed to fetch tables:', e);
+      this.logger.error('Failed to fetch tables:', e);
       this.setError(e);
     }
   }
@@ -103,7 +107,7 @@ export class WatchedQuery extends BaseObserver<WatchedQueryListener> implements
       const data = result ?? [];
       this.setData(data);
     } catch (e) {
-      console.error('Failed to fetch data:', e);
+      this.logger.error('Failed to fetch data:', e);
       this.setError(e);
     }
   }
diff --git a/packages/react/src/hooks/useQuery.ts b/packages/react/src/hooks/useQuery.ts
index b5701027..59c5225c 100644
--- a/packages/react/src/hooks/useQuery.ts
+++ b/packages/react/src/hooks/useQuery.ts
@@ -42,6 +42,7 @@ export const useQuery = <T = any>(
   options: AdditionalOptions = { runQueryOnce: false }
 ): QueryResult<T> => {
   const powerSync = usePowerSync();
+  const logger = powerSync.logger;
   if (!powerSync) {
     return { isLoading: false, isFetching: false, data: [], error: new Error('PowerSync not configured.') };
   }
@@ -50,7 +51,7 @@ export const useQuery = <T = any>(
   try {
     parsedQuery = parseQuery(query, parameters);
   } catch (error) {
-    console.error('Failed to parse query:', error);
+    logger.error('Failed to parse query:', error);
     return { isLoading: false, isFetching: false, data: [], error };
   }
 
@@ -107,7 +108,7 @@ export const useQuery = <T = any>(
 
       handleResult(result);
     } catch (e) {
-      console.error('Failed to fetch data:', e);
+      logger.error('Failed to fetch data:', e);
       handleError(e);
     }
   };
@@ -122,7 +123,7 @@ export const useQuery = <T = any>(
 
       setTables(tables);
     } catch (e) {
-      console.error('Failed to fetch tables:', e);
+      logger.error('Failed to fetch tables:', e);
       handleError(e);
     }
   };
diff --git a/packages/vue/src/composables/useQuery.ts b/packages/vue/src/composables/useQuery.ts
index 57295e65..ca09ea3d 100644
--- a/packages/vue/src/composables/useQuery.ts
+++ b/packages/vue/src/composables/useQuery.ts
@@ -65,6 +65,7 @@ export const useQuery = <T = any>(
   let fetchData: () => Promise<void> | undefined;
 
   const powerSync = usePowerSync();
+  const logger = powerSync.value.logger;
 
   const finishLoading = () => {
     isLoading.value = false;
@@ -99,7 +100,7 @@ export const useQuery = <T = any>(
       const result = await executor();
       handleResult(result);
     } catch (e) {
-      console.error('Failed to fetch data:', e);
+      logger.error('Failed to fetch data:', e);
       handleError(e);
     }
   };
@@ -114,7 +115,7 @@ export const useQuery = <T = any>(
     try {
       parsedQuery = parseQuery(queryValue, toValue(sqlParameters).map(toValue));
     } catch (e) {
-      console.error('Failed to parse query:', e);
+      logger.error('Failed to parse query:', e);
       handleError(e);
       return;
     }
@@ -125,7 +126,7 @@ export const useQuery = <T = any>(
       try {
         resolvedTables = await powerSync.value.resolveTables(sql, parameters, options);
       } catch (e) {
-        console.error('Failed to fetch tables:', e);
+        logger.error('Failed to fetch tables:', e);
         handleError(e);
         return;
       }
diff --git a/packages/web/src/db/adapters/AbstractWebSQLOpenFactory.ts b/packages/web/src/db/adapters/AbstractWebSQLOpenFactory.ts
index 2e1755e3..134a2b2a 100644
--- a/packages/web/src/db/adapters/AbstractWebSQLOpenFactory.ts
+++ b/packages/web/src/db/adapters/AbstractWebSQLOpenFactory.ts
@@ -26,7 +26,7 @@ export abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
       resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() }
     } = this;
     if (ssrMode && !disableSSRWarning) {
-      console.warn(
+      this.logger.warn(
         `
   Running PowerSync in SSR mode.
   Only empty query results will be returned.
@@ -35,7 +35,7 @@ export abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
     }
 
     if (!enableMultiTabs) {
-      console.warn(
+      this.logger.warn(
         'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
       );
     }

From 637ac75e875e1122cff0f92f26563e45daa74535 Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Tue, 8 Apr 2025 11:44:34 +0200
Subject: [PATCH 3/8] Changeset entries.

---
 .changeset/dirty-buttons-hunt.md | 7 +++++++
 .changeset/fresh-jobs-explain.md | 5 +++++
 .changeset/green-rings-judge.md  | 5 +++++
 3 files changed, 17 insertions(+)
 create mode 100644 .changeset/dirty-buttons-hunt.md
 create mode 100644 .changeset/fresh-jobs-explain.md
 create mode 100644 .changeset/green-rings-judge.md

diff --git a/.changeset/dirty-buttons-hunt.md b/.changeset/dirty-buttons-hunt.md
new file mode 100644
index 00000000..cabfca0e
--- /dev/null
+++ b/.changeset/dirty-buttons-hunt.md
@@ -0,0 +1,7 @@
+---
+'@powersync/attachments': patch
+'@powersync/react': patch
+'@powersync/vue': patch
+---
+
+Using newly exposed logger from AbstractPowerSyncDatabase to have controlled logging instead of using console based logging.
diff --git a/.changeset/fresh-jobs-explain.md b/.changeset/fresh-jobs-explain.md
new file mode 100644
index 00000000..6e972171
--- /dev/null
+++ b/.changeset/fresh-jobs-explain.md
@@ -0,0 +1,5 @@
+---
+'@powersync/common': minor
+---
+
+Exposing logger on AbstractPowerSyncDatabase.
diff --git a/.changeset/green-rings-judge.md b/.changeset/green-rings-judge.md
new file mode 100644
index 00000000..7f24b955
--- /dev/null
+++ b/.changeset/green-rings-judge.md
@@ -0,0 +1,5 @@
+---
+'@powersync/web': patch
+---
+
+Updated db and sync workers to respect log levels.

From 5609dee27fb52aebf392f2c25a9f102a00708d5a Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Tue, 8 Apr 2025 13:48:38 +0200
Subject: [PATCH 4/8] Reverting helper package's logging to console in test
 environments.

---
 packages/attachments/src/AbstractAttachmentQueue.ts | 2 +-
 packages/react/src/WatchedQuery.ts                  | 2 +-
 packages/react/src/hooks/useQuery.ts                | 2 +-
 packages/vue/src/composables/useQuery.ts            | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/packages/attachments/src/AbstractAttachmentQueue.ts b/packages/attachments/src/AbstractAttachmentQueue.ts
index a5f4d4d2..b056007f 100644
--- a/packages/attachments/src/AbstractAttachmentQueue.ts
+++ b/packages/attachments/src/AbstractAttachmentQueue.ts
@@ -92,7 +92,7 @@ export abstract class AbstractAttachmentQueue<T extends AttachmentQueueOptions =
   }
 
   get logger() {
-    return this.powersync.logger;
+    return this.powersync.logger ?? console;
   }
 
   protected get storage() {
diff --git a/packages/react/src/WatchedQuery.ts b/packages/react/src/WatchedQuery.ts
index a4a08614..250f91d6 100644
--- a/packages/react/src/WatchedQuery.ts
+++ b/packages/react/src/WatchedQuery.ts
@@ -47,7 +47,7 @@ export class WatchedQuery extends BaseObserver<WatchedQueryListener> implements
   }
 
   get logger() {
-    return this.db.logger;
+    return this.db.logger ?? console;
   }
 
   addTemporaryHold() {
diff --git a/packages/react/src/hooks/useQuery.ts b/packages/react/src/hooks/useQuery.ts
index 59c5225c..b7400eae 100644
--- a/packages/react/src/hooks/useQuery.ts
+++ b/packages/react/src/hooks/useQuery.ts
@@ -42,7 +42,7 @@ export const useQuery = <T = any>(
   options: AdditionalOptions = { runQueryOnce: false }
 ): QueryResult<T> => {
   const powerSync = usePowerSync();
-  const logger = powerSync.logger;
+  const logger = powerSync?.logger ?? console;
   if (!powerSync) {
     return { isLoading: false, isFetching: false, data: [], error: new Error('PowerSync not configured.') };
   }
diff --git a/packages/vue/src/composables/useQuery.ts b/packages/vue/src/composables/useQuery.ts
index ca09ea3d..2a5d32f2 100644
--- a/packages/vue/src/composables/useQuery.ts
+++ b/packages/vue/src/composables/useQuery.ts
@@ -65,7 +65,7 @@ export const useQuery = <T = any>(
   let fetchData: () => Promise<void> | undefined;
 
   const powerSync = usePowerSync();
-  const logger = powerSync.value.logger;
+  const logger = powerSync?.value?.logger ?? console;
 
   const finishLoading = () => {
     isLoading.value = false;

From 189d4a0677145414ba3388203f0a50ecc442671c Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Thu, 17 Apr 2025 08:54:34 +0200
Subject: [PATCH 5/8] Changed .worker.ts console.log to console.debug

---
 packages/web/src/worker/sync/SharedSyncImplementation.worker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts b/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts
index 8c8e1266..cb32a9c7 100644
--- a/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts
+++ b/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts
@@ -20,7 +20,7 @@ _self.onconnect = function (event: MessageEvent<string>) {
   port.addEventListener('message', (event) => {
     const payload = event.data as ManualSharedSyncPayload;
     if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
-      console.log('closing shared for port', port);
+      console.debug('closing shared for port', port);
       sharedSyncImplementation.removePort(port);
     }
   });

From 8a4f12bf55ad4532980b0b4977cbea2621a075a0 Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Tue, 22 Apr 2025 16:43:46 +0200
Subject: [PATCH 6/8] Using logger types from @powersync/common for node
 package.

---
 .changeset/calm-roses-poke.md               | 5 +++++
 packages/node/src/sync/stream/NodeRemote.ts | 3 +--
 2 files changed, 6 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/calm-roses-poke.md

diff --git a/.changeset/calm-roses-poke.md b/.changeset/calm-roses-poke.md
new file mode 100644
index 00000000..e87a34ff
--- /dev/null
+++ b/.changeset/calm-roses-poke.md
@@ -0,0 +1,5 @@
+---
+'@powersync/node': patch
+---
+
+Using logger types from @powersync/common.
diff --git a/packages/node/src/sync/stream/NodeRemote.ts b/packages/node/src/sync/stream/NodeRemote.ts
index b0c14748..b05be330 100644
--- a/packages/node/src/sync/stream/NodeRemote.ts
+++ b/packages/node/src/sync/stream/NodeRemote.ts
@@ -1,8 +1,7 @@
 import * as os from 'node:os';
 
-import { ILogger } from 'js-logger';
-
 import {
+  type ILogger,
   AbstractRemote,
   AbstractRemoteOptions,
   BSONImplementation,

From 9854fb01e3f20fbd9a2c2dc55eabd07b05b8f2d0 Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Tue, 22 Apr 2025 16:44:58 +0200
Subject: [PATCH 7/8] Removed last console.debug calls from workers.

---
 packages/web/src/worker/db/WASQLiteDB.worker.ts                 | 1 -
 packages/web/src/worker/sync/SharedSyncImplementation.worker.ts | 1 -
 2 files changed, 2 deletions(-)

diff --git a/packages/web/src/worker/db/WASQLiteDB.worker.ts b/packages/web/src/worker/db/WASQLiteDB.worker.ts
index 169f40f4..2ffd8be8 100644
--- a/packages/web/src/worker/db/WASQLiteDB.worker.ts
+++ b/packages/web/src/worker/db/WASQLiteDB.worker.ts
@@ -97,7 +97,6 @@ if (typeof SharedWorkerGlobalScope !== 'undefined') {
   const _self: SharedWorkerGlobalScope = self as any;
   _self.onconnect = function (event: MessageEvent<string>) {
     const port = event.ports[0];
-    console.debug('Exposing shared db on port', port);
     Comlink.expose(openDBShared, port);
   };
 } else {
diff --git a/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts b/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts
index 2379524d..ad764445 100644
--- a/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts
+++ b/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts
@@ -22,7 +22,6 @@ _self.onconnect = function (event: MessageEvent<string>) {
   port.addEventListener('message', (event) => {
     const payload = event.data as ManualSharedSyncPayload;
     if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
-      console.debug('closing shared for port', port);
       sharedSyncImplementation.removePort(port);
     }
   });

From 0857d51cf83c8c27e2946be4460cce498a7b4877 Mon Sep 17 00:00:00 2001
From: Christiaan Landman <chriz.ek@gmail.com>
Date: Wed, 23 Apr 2025 12:18:46 +0200
Subject: [PATCH 8/8] Minor cleanup.

---
 packages/web/src/db/sync/WebStreamingSyncImplementation.ts | 2 +-
 packages/web/src/worker/sync/BroadcastLogger.ts            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/web/src/db/sync/WebStreamingSyncImplementation.ts b/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
index 105858be..10f8905d 100644
--- a/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
+++ b/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
@@ -28,7 +28,7 @@ export class WebStreamingSyncImplementation extends AbstractStreamingSyncImpleme
   obtainLock<T>(lockOptions: LockOptions<T>): Promise<T> {
     const identifier = `streaming-sync-${lockOptions.type}-${this.webOptions.identifier}`;
     if (lockOptions.type == LockType.SYNC) {
-      (this.logger ?? createLogger('WebStreamingSyncImplementation')).debug('requesting lock for ', identifier);
+      this.logger.debug('requesting lock for ', identifier);
     }
     return getNavigatorLocks().request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
   }
diff --git a/packages/web/src/worker/sync/BroadcastLogger.ts b/packages/web/src/worker/sync/BroadcastLogger.ts
index 4fa1aba6..01b01548 100644
--- a/packages/web/src/worker/sync/BroadcastLogger.ts
+++ b/packages/web/src/worker/sync/BroadcastLogger.ts
@@ -13,7 +13,7 @@ export class BroadcastLogger implements ILogger {
   ERROR: ILogLevel;
   OFF: ILogLevel;
 
-  private currentLevel: ILogLevel = Logger.INFO;
+  private currentLevel: ILogLevel = LogLevel.INFO;
 
   constructor(protected clients: WrappedSyncPort[]) {
     this.TRACE = LogLevel.TRACE;