diff --git a/.changeset/calm-roses-poke.md b/.changeset/calm-roses-poke.md
new file mode 100644
index 000000000..e87a34ff1
--- /dev/null
+++ b/.changeset/calm-roses-poke.md
@@ -0,0 +1,5 @@
+---
+'@powersync/node': patch
+---
+
+Using logger types from @powersync/common.
diff --git a/.changeset/dirty-buttons-hunt.md b/.changeset/dirty-buttons-hunt.md
new file mode 100644
index 000000000..cabfca0e0
--- /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 000000000..6e9721717
--- /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 000000000..7f24b955b
--- /dev/null
+++ b/.changeset/green-rings-judge.md
@@ -0,0 +1,5 @@
+---
+'@powersync/web': patch
+---
+
+Updated db and sync workers to respect log levels.
diff --git a/packages/attachments/src/AbstractAttachmentQueue.ts b/packages/attachments/src/AbstractAttachmentQueue.ts
index 888d38a53..b056007f1 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 ?? console;
+  }
+
   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 2e71083e7..c56507359 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/node/src/sync/stream/NodeRemote.ts b/packages/node/src/sync/stream/NodeRemote.ts
index b0c147484..b05be330d 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,
diff --git a/packages/react/src/WatchedQuery.ts b/packages/react/src/WatchedQuery.ts
index be52a0085..250f91d6d 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 ?? console;
+  }
+
   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 b5701027d..b7400eaea 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 ?? console;
   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 57295e65a..2a5d32f25 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 ?? console;
 
   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 0f4e6647f..faa252d85 100644
--- a/packages/web/src/db/adapters/AbstractWebSQLOpenFactory.ts
+++ b/packages/web/src/db/adapters/AbstractWebSQLOpenFactory.ts
@@ -25,7 +25,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.
@@ -34,7 +34,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.'
       );
     }
diff --git a/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts b/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts
index 6217b35dc..129a3b130 100644
--- a/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts
+++ b/packages/web/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts
@@ -1,4 +1,4 @@
-import { DBAdapter } from '@powersync/common';
+import { type ILogLevel, DBAdapter } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
@@ -20,6 +20,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 +78,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 +88,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 916541d9f..dadb1276c 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 05d60f0a2..10f8905d4 100644
--- a/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
+++ b/packages/web/src/db/sync/WebStreamingSyncImplementation.ts
@@ -1,6 +1,7 @@
 import {
   AbstractStreamingSyncImplementation,
   AbstractStreamingSyncImplementationOptions,
+  createLogger,
   LockOptions,
   LockType
 } from '@powersync/common';
@@ -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.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 7e28b024d..2ffd8be89 100644
--- a/packages/web/src/worker/db/WASQLiteDB.worker.ts
+++ b/packages/web/src/worker/db/WASQLiteDB.worker.ts
@@ -6,8 +6,16 @@ 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 { createBaseLogger, createLogger } from '@powersync/common';
+
+const baseLogger = createBaseLogger();
+baseLogger.useDefaults();
+const logger = createLogger('db-worker');
 
 /**
  * Keeps track of open DB connections and the clients which
@@ -39,11 +47,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 +76,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;
       })
     };
@@ -86,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/BroadcastLogger.ts b/packages/web/src/worker/sync/BroadcastLogger.ts
index 2cb6b1d1e..01b015489 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 = LogLevel.INFO;
+
   constructor(protected clients: WrappedSyncPort[]) {
     this.TRACE = LogLevel.TRACE;
     this.DEBUG = LogLevel.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 LogLevel.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 13ec31709..65c0504e4 100644
--- a/packages/web/src/worker/sync/SharedSyncImplementation.ts
+++ b/packages/web/src/worker/sync/SharedSyncImplementation.ts
@@ -1,6 +1,7 @@
 import {
   type AbstractStreamingSyncImplementation,
   type ILogger,
+  type ILogLevel,
   type LockOptions,
   type PowerSyncConnectionOptions,
   type StreamingSyncImplementation,
@@ -146,6 +147,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.
    */
@@ -235,7 +241,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;
     }
 
@@ -312,7 +318,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);
diff --git a/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts b/packages/web/src/worker/sync/SharedSyncImplementation.worker.ts
index 9716aa4d9..ad7644456 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.log('closing shared for port', port);
       sharedSyncImplementation.removePort(port);
     }
   });