diff --git a/src/blockstore/encrypt-helpers.ts b/src/blockstore/encrypt-helpers.ts
index 041a2ec9..80dbd55b 100644
--- a/src/blockstore/encrypt-helpers.ts
+++ b/src/blockstore/encrypt-helpers.ts
@@ -141,7 +141,13 @@ function hexStringToUint8Array(hexString: string) {
   return uint8Array;
 }
 
-export async function encryptedEncodeCarFile(logger: Logger, crypto: CryptoOpts, key: string, rootCid: AnyLink, t: CarMakeable): Promise<AnyBlock> {
+export async function encryptedEncodeCarFile(
+  logger: Logger,
+  crypto: CryptoOpts,
+  key: string,
+  rootCid: AnyLink,
+  t: CarMakeable,
+): Promise<AnyBlock> {
   const encryptionKey = hexStringToUint8Array(key);
   const encryptedBlocks = new MemoryBlockstore();
   const cidsToEncrypt = [] as AnyLink[];
diff --git a/src/blockstore/loader.ts b/src/blockstore/loader.ts
index 36d3971a..fa41de40 100644
--- a/src/blockstore/loader.ts
+++ b/src/blockstore/loader.ts
@@ -131,10 +131,13 @@ export class Loader implements Loadable {
   constructor(name: string, ebOpts: BlockstoreOpts) {
     this.name = name;
     // console.log("Loader", name, ebOpts)
-    this.ebOpts = defaultedBlockstoreRuntime({
-      ...ebOpts,
-      name,
-    }, "Loader");
+    this.ebOpts = defaultedBlockstoreRuntime(
+      {
+        ...ebOpts,
+        name,
+      },
+      "Loader",
+    );
     this.logger = this.ebOpts.logger;
   }
 
diff --git a/src/blockstore/remote-wal.ts b/src/blockstore/remote-wal.ts
index 909859b8..f0997cec 100644
--- a/src/blockstore/remote-wal.ts
+++ b/src/blockstore/remote-wal.ts
@@ -21,7 +21,6 @@ export abstract class RemoteWAL {
   // readonly STORAGE_VERSION: string = STORAGE_VERSION;
   readonly loader: Loadable;
 
-
   readonly _ready = new ResolveOnce<void>();
 
   async ready() {
@@ -139,9 +138,14 @@ export abstract class RemoteWAL {
         const res = await Promise.allSettled(uploads);
         const errors = res.filter((r) => r.status === "rejected") as PromiseRejectedResult[];
         if (errors.length) {
-          throw this.logger.Error().Any("errors",
-            errors.map((e) => e.reason)
-          ).Msg("error uploading").AsError();
+          throw this.logger
+            .Error()
+            .Any(
+              "errors",
+              errors.map((e) => e.reason),
+            )
+            .Msg("error uploading")
+            .AsError();
 
           errors[0].reason;
         }
diff --git a/src/blockstore/store-factory.ts b/src/blockstore/store-factory.ts
index 28a2f97f..1ecbf2a6 100644
--- a/src/blockstore/store-factory.ts
+++ b/src/blockstore/store-factory.ts
@@ -137,9 +137,12 @@ async function remoteWalFactory(iurl: URL, loader: Loadable): Promise<RemoteWAL>
 }
 
 export async function testStoreFactory(url: URL, ilogger?: Logger): Promise<TestStore> {
-  const logger = ensureLogger({
-    logger: ilogger,
-  }, "testStoreFactory");
+  const logger = ensureLogger(
+    {
+      logger: ilogger,
+    },
+    "testStoreFactory",
+  );
   switch (url.protocol) {
     case "file:": {
       const { FileTestStore } = await import("../runtime/store-file.js");
diff --git a/src/blockstore/store-memory.ts b/src/blockstore/store-memory.ts
index f22536ed..8e418583 100644
--- a/src/blockstore/store-memory.ts
+++ b/src/blockstore/store-memory.ts
@@ -11,7 +11,7 @@ export class MemoryDataStore extends DataStore {
   readonly logger: Logger;
   constructor(name: string, url: URL, logger: Logger) {
     super(name, url);
-    this.logger = ensureLogger(logger,  "MemoryDataStore", { name, url });
+    this.logger = ensureLogger(logger, "MemoryDataStore", { name, url });
   }
 
   async load(cid: AnyLink): Promise<AnyBlock> {
diff --git a/src/blockstore/task-manager.ts b/src/blockstore/task-manager.ts
index 98ed1cc1..d48bb9f8 100644
--- a/src/blockstore/task-manager.ts
+++ b/src/blockstore/task-manager.ts
@@ -47,7 +47,7 @@ export class TaskManager {
       this.queue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
     } catch (err) {
       if (first.retries++ > 3) {
-        this.logger.Error().Str("cid", first.cid).Msg("failed to process event block after 3 retries")
+        this.logger.Error().Str("cid", first.cid).Msg("failed to process event block after 3 retries");
         this.queue = this.queue.filter(({ cid }) => cid !== first.cid);
       }
       await new Promise((resolve) => setTimeout(resolve, 50));
diff --git a/src/blockstore/transaction.ts b/src/blockstore/transaction.ts
index e1e07c5c..89f42ecd 100644
--- a/src/blockstore/transaction.ts
+++ b/src/blockstore/transaction.ts
@@ -46,7 +46,7 @@ export class CarTransaction extends MemoryBlockstore implements CarMakeable {
 export function defaultedBlockstoreRuntime(
   opts: BlockstoreOpts,
   component: string,
-  ctx?: Record<string, unknown>
+  ctx?: Record<string, unknown>,
 ): BlockstoreRuntime {
   return {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -102,7 +102,7 @@ export class BaseBlockstore implements BlockFetcher {
   constructor(ebOpts: BlockstoreOpts = {}) {
     // console.log("BaseBlockstore", ebOpts)
     this.ebOpts = defaultedBlockstoreRuntime(ebOpts, "BaseBlockstore");
-    this.logger = this.ebOpts.logger
+    this.logger = this.ebOpts.logger;
   }
 
   async get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block<T, C, A, V> | undefined> {
@@ -167,7 +167,7 @@ export class EncryptedBlockstore extends BaseBlockstore {
     this.logger = ensureLogger(ebOpts, "EncryptedBlockstore");
     const { name } = ebOpts;
     if (!name) {
-      throw  this.logger.Error().Msg("name required").AsError();
+      throw this.logger.Error().Msg("name required").AsError();
     }
     this.name = name;
     this.loader = new Loader(this.name, ebOpts);
diff --git a/src/crdt-helpers.ts b/src/crdt-helpers.ts
index 4206fb86..6d788e65 100644
--- a/src/crdt-helpers.ts
+++ b/src/crdt-helpers.ts
@@ -156,7 +156,7 @@ export async function getValueFromCrdt<T extends DocTypes>(
   blocks: BaseBlockstore,
   head: ClockHead,
   key: string,
-  logger: Logger
+  logger: Logger,
 ): Promise<DocValue<T>> {
   if (!head.length) throw logger.Error().Msg("Getting from an empty database").AsError();
   const link = await get(blocks, head, key);
@@ -226,13 +226,23 @@ export async function clockChangesSince<T extends DocTypes>(
   head: ClockHead,
   since: ClockHead,
   opts: ChangesOptions,
-  logger: Logger
+  logger: Logger,
 ): Promise<{ result: DocUpdate<T>[]; head: ClockHead }> {
   const eventsFetcher = (
     opts.dirty ? new DirtyEventFetcher<Operation>(blocks) : new EventFetcher<Operation>(blocks)
   ) as EventFetcher<Operation>;
   const keys = new Set<string>();
-  const updates = await gatherUpdates<T>(blocks, eventsFetcher, head, since, [], keys, new Set<string>(), opts.limit || Infinity, logger);
+  const updates = await gatherUpdates<T>(
+    blocks,
+    eventsFetcher,
+    head,
+    since,
+    [],
+    keys,
+    new Set<string>(),
+    opts.limit || Infinity,
+    logger,
+  );
   return { result: updates.reverse(), head };
 }
 
@@ -245,7 +255,7 @@ async function gatherUpdates<T extends DocTypes>(
   keys: Set<string>,
   didLinks: Set<string>,
   limit: number,
-  logger: Logger
+  logger: Logger,
 ): Promise<DocUpdate<T>[]> {
   if (limit <= 0) return updates;
   // if (Math.random() < 0.001) console.log('gatherUpdates', head.length, since.length, updates.length)
diff --git a/src/indexer.ts b/src/indexer.ts
index 20bd1d47..ac8ce842 100644
--- a/src/indexer.ts
+++ b/src/indexer.ts
@@ -108,8 +108,9 @@ export class Index<K extends IndexKeyType, T extends DocTypes, R extends DocFrag
         if (this.mapFnString) {
           // we already initialized from application code
           if (this.mapFnString !== meta.map) {
-            this.logger.Warn().Msg(
-              `cannot apply different mapFn meta: old mapFnString ${this.mapFnString} new mapFnString ${meta.map}`);
+            this.logger
+              .Warn()
+              .Msg(`cannot apply different mapFn meta: old mapFnString ${this.mapFnString} new mapFnString ${meta.map}`);
             // throw new Error('cannot apply different mapFn meta')
           } else {
             this.byId.cid = meta.byId;
diff --git a/src/runtime/store-file.ts b/src/runtime/store-file.ts
index f96d6798..be977410 100644
--- a/src/runtime/store-file.ts
+++ b/src/runtime/store-file.ts
@@ -16,7 +16,7 @@ function ensureVersion(url: URL): URL {
 }
 
 const versionFiles = new Map<string, ResolveOnce<void>>();
-async function ensureVersionFile(path: string, logger:Logger): Promise<string> {
+async function ensureVersionFile(path: string, logger: Logger): Promise<string> {
   let once = versionFiles.get(path);
   if (!once) {
     once = new ResolveOnce<void>();
@@ -48,7 +48,7 @@ async function getPath(url: URL, logger: Logger): Promise<string> {
   const name = url.searchParams.get("name");
   if (!name) throw logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
   const version = url.searchParams.get("version");
-  if (!version) throw  logger.Error().Str("url", url.toString()).Msg(`version not found`).AsError();
+  if (!version) throw logger.Error().Str("url", url.toString()).Msg(`version not found`).AsError();
   // const index = url.searchParams.has("index");
   // if (index) name += index;
   return ensureVersionFile(SysContainer.join(basePath, version, name), logger);
@@ -125,9 +125,7 @@ export class FileMetaStore extends MetaStore {
   readonly branches = new Set<string>();
 
   constructor(url: URL, name: string, logger: Logger) {
-    super(name,
-      ensureVersion(url),
-      ensureLogger(logger, "FileMetaStore", { name, url }));
+    super(name, ensureVersion(url), ensureLogger(logger, "FileMetaStore", { name, url }));
   }
 
   async filePathForBranch(branch: string): Promise<string> {
@@ -239,12 +237,19 @@ function toArrayBuffer(buffer: Buffer) {
 
 export class FileTestStore implements TestStore {
   readonly logger: Logger;
-  constructor(readonly url: URL, logger: Logger) {
+  constructor(
+    readonly url: URL,
+    logger: Logger,
+  ) {
     this.logger = ensureLogger(logger, "FileTestStore", { url });
   }
 
   async get(key: string) {
-    const dbFile = SysContainer.join(await getPath(this.url, this.logger), getStore(this.url, this.logger), getFileName(this.url, key, this.logger));
+    const dbFile = SysContainer.join(
+      await getPath(this.url, this.logger),
+      getStore(this.url, this.logger),
+      getFileName(this.url, key, this.logger),
+    );
     const buffer = await SysContainer.readfile(dbFile);
     return toArrayBuffer(buffer);
   }
diff --git a/src/runtime/store-indexdb.ts b/src/runtime/store-indexdb.ts
index b4cb58db..8462ab2e 100644
--- a/src/runtime/store-indexdb.ts
+++ b/src/runtime/store-indexdb.ts
@@ -120,7 +120,7 @@ export function getIndexDBName(iurl: URL, logger: Logger): DbName {
   const dbName = url.searchParams.get("name");
   if (!dbName) throw logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
   const result = joinDBName(fullDb, dbName);
-  let objStore = getStore(url,logger);
+  let objStore = getStore(url, logger);
   if (url.searchParams.has("index")) {
     objStore = joinDBName(url.searchParams.get("index") || "idx", objStore);
   }
@@ -178,8 +178,8 @@ export class EnsureDB {
     this.url = url;
     this.logger = ensureLogger(logger, "EnsureDB", {
       id: this.id,
-      url: url
-  });
+      url: url,
+    });
   }
   async get<T>(dbWorkFun: (arg0: SimpleDb) => Promise<T>): Promise<T> {
     return connectIdb(this.url, this.logger, dbWorkFun);
@@ -274,8 +274,9 @@ export class IndexDBRemoteWAL extends RemoteWALBase {
   constructor(loader: Loadable, url: URL) {
     super(loader, ensureVersion(url));
     this.logger = ensureLogger(loader.logger, "IndexDBRemoteWAL", {
-      url, name: loader.name
-    })
+      url,
+      name: loader.name,
+    });
     this.ensureDB = new EnsureDB(this.url, this.logger);
   }
 
@@ -337,10 +338,14 @@ export class IndexDBMetaStore extends MetaStoreBase {
   readonly ensureDB: EnsureDB;
 
   constructor(name: string, url: URL, logger: Logger) {
-    super(name, ensureVersion(url), ensureLogger(logger, "IndexDBMetaStore", {
+    super(
       name,
-      url
-    }));
+      ensureVersion(url),
+      ensureLogger(logger, "IndexDBMetaStore", {
+        name,
+        url,
+      }),
+    );
     this.ensureDB = new EnsureDB(this.url, this.logger);
   }
 
@@ -405,10 +410,13 @@ export class IndexDBMetaStore extends MetaStoreBase {
 
 export class IndexDBTestStore implements TestStore {
   readonly logger: Logger;
-  constructor(readonly url: URL, logger: Logger) {
+  constructor(
+    readonly url: URL,
+    logger: Logger,
+  ) {
     this.logger = ensureLogger(logger, "IndexDBTestStore", {
-      url
-    })
+      url,
+    });
   }
   async get(key: string) {
     const ensureDB = new EnsureDB(this.url, this.logger);
diff --git a/src/runtime/store-sql/connect-sql-node.ts b/src/runtime/store-sql/connect-sql-node.ts
index f95ae35c..9b2cb69e 100644
--- a/src/runtime/store-sql/connect-sql-node.ts
+++ b/src/runtime/store-sql/connect-sql-node.ts
@@ -21,10 +21,14 @@ export class ConnectSQL extends ConnectionBase {
   constructor(store: StoreOptions, iopts: Partial<SQLOpts> = {}) {
     super(ensureLogger(iopts, "ConnectSQL"));
     this.store = store;
-    const opts = ensureSQLOpts(new URL("noready://"), {
-      ...iopts,
-      logger: this.logger
-    }, "ConnectSQL");
+    const opts = ensureSQLOpts(
+      new URL("noready://"),
+      {
+        ...iopts,
+        logger: this.logger,
+      },
+      "ConnectSQL",
+    );
     this.textEncoder = opts.textEncoder;
   }
 
diff --git a/src/runtime/store-sql/store-sql.ts b/src/runtime/store-sql/store-sql.ts
index 3a5b8491..2f6e99f3 100644
--- a/src/runtime/store-sql/store-sql.ts
+++ b/src/runtime/store-sql/store-sql.ts
@@ -117,7 +117,7 @@ export class SQLDataStore extends DataStore {
 
   readonly logger: Logger;
   constructor(url: URL, name: string, ilogger: Logger) {
-    const logger = ensureLogger(ilogger, "SQLDataStore", { name, url })
+    const logger = ensureLogger(ilogger, "SQLDataStore", { name, url });
     super(name, ensureSQLVersion(url, logger));
     this.logger = logger;
   }
diff --git a/src/runtime/store-sql/store-version-factory.ts b/src/runtime/store-sql/store-version-factory.ts
index 985f6452..2af2c3fe 100644
--- a/src/runtime/store-sql/store-version-factory.ts
+++ b/src/runtime/store-sql/store-version-factory.ts
@@ -3,7 +3,7 @@ import { ensureLogger, LoggerOpts } from "../../utils";
 import { DBConnection, DataSQLStore, MetaSQLStore, WalSQLStore } from "./types";
 import { SQLITE_VERSION } from "./v0.19-sqlite/version";
 
-export function ensureSQLVersion(url: URL, opts: LoggerOpts|Logger): URL {
+export function ensureSQLVersion(url: URL, opts: LoggerOpts | Logger): URL {
   if (url.searchParams.get("version")) return url;
 
   switch (url.protocol) {
diff --git a/src/utils.ts b/src/utils.ts
new file mode 100644
index 00000000..827ff649
--- /dev/null
+++ b/src/utils.ts
@@ -0,0 +1,46 @@
+import { Logger, LoggerImpl, IsLogger } from "@adviser/cement";
+
+const globalLogger: Logger = new LoggerImpl();
+
+export interface LoggerOpts {
+  readonly logger?: Logger;
+}
+
+export function ensureLogger(
+  optsOrLogger: Partial<LoggerOpts> | Logger,
+  componentName: string,
+  ctx?: Record<string, unknown>,
+): Logger {
+  // if (!opts?.logger) {
+  //   throw new Error("logger is required");
+  // }
+  let logger = globalLogger;
+  if (IsLogger(optsOrLogger)) {
+    logger = optsOrLogger;
+  } else if (optsOrLogger && IsLogger(optsOrLogger.logger)) {
+    logger = optsOrLogger.logger;
+  }
+  const cLogger = logger.With().Module(componentName);
+  if (ctx) {
+    for (const [key, value] of Object.entries(ctx)) {
+      switch (typeof value) {
+        case "string":
+          cLogger.Str(key, value);
+          break;
+        case "number":
+          cLogger.Uint64(key, value);
+          break;
+        default:
+          if (value instanceof Date) {
+            cLogger.Str(key, value.toISOString());
+          } else if (value instanceof URL) {
+            cLogger.Str(key, value.toString());
+          } else {
+            cLogger.Any(key, value);
+          }
+          break;
+      }
+    }
+  }
+  return cLogger.Logger();
+}