feat: add logger system

Author: Julien-R44

packages/verrou/package.json

@@ -41,7 +41,8 @@
   "dependencies": {
     "@lukeed/ms": "^2.0.2",
     "@poppinss/utils": "^6.7.0",
-    "async-mutex": "^0.4.0"
+    "async-mutex": "^0.4.0",
+    "typescript-log": "^2.0.0"
   },
   "devDependencies": {
     "@aws-sdk/client-dynamodb": "^3.484.0",

packages/verrou/src/drivers/dynamodb.ts

@@ -66,20 +66,6 @@ export class DynamoDBStore implements LockStore {
     }
   }
 
-  /**
-   * Get the current owner of a lock
-   */
-  async #getCurrentOwner(key: string) {
-    await this.#initialized
-    const command = new GetItemCommand({
-      TableName: this.#tableName,
-      Key: { key: { S: key } },
-    })
-
-    const result = await this.#client.send(command)
-    return result.Item?.owner?.S
-  }
-
   /**
    * Save a lock
    */

packages/verrou/src/lock.ts

@@ -1,25 +1,18 @@
 import { setTimeout } from 'node:timers/promises'
 
 import { E_LOCK_TIMEOUT } from './errors.js'
-import type {
-  LockAcquireOptions,
-  LockFactoryConfig,
-  LockFactoryOptions,
-  LockStore,
-} from './types/main.js'
+import type { LockAcquireOptions, LockFactoryConfig, LockStore } from './types/main.js'
 
 export class Lock {
-  #config: LockFactoryConfig
   #owner: string
 
   constructor(
     protected readonly key: string,
     protected readonly lockStore: LockStore,
-    options: LockFactoryOptions = {},
+    protected config: LockFactoryConfig,
     owner?: string,
     protected ttl?: number | null,
   ) {
-    this.#config = { retry: { attempts: null, delay: 250, ...options.retry } }
     this.#owner = owner ?? this.#generateOwner()
   }
 
@@ -44,7 +37,7 @@ export class Lock {
     let attemptsDone = 0
     const start = Date.now()
     const attemptsMax =
-      options?.retry?.attempts ?? this.#config.retry.attempts ?? Number.POSITIVE_INFINITY
+      options?.retry?.attempts ?? this.config.retry.attempts ?? Number.POSITIVE_INFINITY
 
     while (attemptsDone++ < attemptsMax) {
       const result = await this.lockStore.save(this.key, this.#owner, this.ttl)
@@ -53,12 +46,14 @@ export class Lock {
       if (attemptsDone === attemptsMax) throw new E_LOCK_TIMEOUT()
 
       const elapsed = Date.now() - start
-      if (this.#config.retry.timeout && elapsed > this.#config.retry.timeout) {
+      if (this.config.retry.timeout && elapsed > this.config.retry.timeout) {
         throw new E_LOCK_TIMEOUT()
       }
 
-      await setTimeout(this.#config.retry.delay ?? 250)
+      await setTimeout(this.config.retry.delay ?? 250)
     }
+
+    this.config.logger.debug({ key: this.key }, 'Lock acquired')
   }
 
   /**

packages/verrou/src/lock_factory.ts

@@ -1,3 +1,5 @@
+import { noopLogger } from 'typescript-log'
+
 import { Lock } from './lock.js'
 import { resolveDuration } from './helpers.js'
 import type { Duration, LockFactoryConfig, LockFactoryOptions, LockStore } from './types/main.js'
@@ -17,7 +19,10 @@ export class LockFactory {
     protected readonly store: LockStore,
     options: LockFactoryOptions = {},
   ) {
-    this.#config = { retry: { attempts: null, delay: 250, ...options.retry } }
+    this.#config = {
+      retry: { attempts: null, delay: 250, ...options.retry },
+      logger: (options.logger ?? noopLogger()).child({ pkg: 'verrou' }),
+    }
   }
 
   /**

packages/verrou/src/types/main.ts

@@ -1,3 +1,5 @@
+import type { Logger } from 'typescript-log'
+
 export * from './drivers.js'
 
 /**
@@ -42,10 +44,12 @@ export interface LockAcquireOptions {
 
 export interface LockFactoryOptions {
   retry?: RetryConfig
+  logger?: Logger
 }
 
 export interface LockFactoryConfig {
   retry: RetryConfig
+  logger: Logger
 }
 
 export interface LockStore {

packages/verrou/src/verrou.ts

@@ -1,3 +1,5 @@
+import { noopLogger, type Logger } from 'typescript-log'
+
 import { LockFactory } from './lock_factory.js'
 import type { Duration, StoreFactory } from './types/main.js'
 
@@ -22,9 +24,15 @@ export class Verrou<KnownStores extends Record<string, StoreFactory>> {
    */
   #storesCache: Map<keyof KnownStores, LockFactory> = new Map()
 
-  constructor(config: { default: keyof KnownStores; stores: KnownStores }) {
+  /**
+   * Logger instance
+   */
+  #logger: Logger
+
+  constructor(config: { default: keyof KnownStores; stores: KnownStores; logger?: Logger }) {
     this.#stores = config.stores
     this.#defaultStoreName = config.default
+    this.#logger = (config.logger ?? noopLogger()).child({ pkg: 'verrou' })
   }
 
   /**
@@ -38,7 +46,10 @@ export class Verrou<KnownStores extends Record<string, StoreFactory>> {
       return this.#storesCache.get(storeToUse)!
     }
 
-    const factory = new LockFactory(this.#stores[storeToUse]!.driver.factory())
+    const factory = new LockFactory(this.#stores[storeToUse]!.driver.factory(), {
+      logger: this.#logger,
+    })
+
     this.#storesCache.set(storeToUse, factory)
 
     return factory

packages/verrou/tests/lock.spec.ts

@@ -1,4 +1,5 @@
 import { test } from '@japa/runner'
+import { noopLogger } from 'typescript-log'
 
 import { Lock } from '../src/lock.js'
 import { E_LOCK_TIMEOUT } from '../src/errors.js'
@@ -8,7 +9,7 @@ import { NullStore } from '../test_helpers/null_store.js'
 test.group('Lock', () => {
   test('acquire', async ({ assert }) => {
     const store = new MemoryStore()
-    const lock = new Lock('foo', store)
+    const lock = new Lock('foo', store, { retry: {}, logger: noopLogger() })
 
     assert.deepEqual(await lock.isLocked(), false)
 
@@ -24,7 +25,10 @@ test.group('Lock', () => {
       }
     }
 
-    const lock = new Lock('foo', new FakeStore(), { retry: { attempts: 2, delay: 10 } })
+    const lock = new Lock('foo', new FakeStore(), {
+      retry: { attempts: 2, delay: 10 },
+      logger: noopLogger(),
+    })
 
     // @ts-ignore
     await assert.rejects(() => lock.acquire(), E_LOCK_TIMEOUT.message)
@@ -39,7 +43,7 @@ test.group('Lock', () => {
       }
     }
 
-    const lock = new Lock('foo', new FakeStore(), { retry: { attempts: 5 } })
+    const lock = new Lock('foo', new FakeStore(), { retry: { attempts: 5 }, logger: noopLogger() })
 
     // @ts-ignore
     await assert.rejects(() => lock.acquire(), E_LOCK_TIMEOUT.message)
@@ -54,7 +58,10 @@ test.group('Lock', () => {
     }
 
     const start = Date.now()
-    const lock = new Lock('foo', new FakeStore(), { retry: { attempts: 5, delay: 100 } })
+    const lock = new Lock('foo', new FakeStore(), {
+      retry: { attempts: 5, delay: 100 },
+      logger: noopLogger(),
+    })
 
     // @ts-ignore
     await assert.rejects(() => lock.acquire(), E_LOCK_TIMEOUT.message)
@@ -71,7 +78,10 @@ test.group('Lock', () => {
     }
 
     const start = Date.now()
-    const lock = new Lock('foo', new FakeStore(), { retry: { timeout: 100, delay: 10 } })
+    const lock = new Lock('foo', new FakeStore(), {
+      retry: { timeout: 100, delay: 10 },
+      logger: noopLogger(),
+    })
 
     // @ts-ignore
     await assert.rejects(() => lock.acquire(), E_LOCK_TIMEOUT.message)
@@ -84,7 +94,7 @@ test.group('Lock', () => {
     assert.plan(3)
 
     const store = new MemoryStore()
-    const lock = new Lock('foo', store)
+    const lock = new Lock('foo', store, { retry: {}, logger: noopLogger() })
 
     assert.deepEqual(await lock.isLocked(), false)
 
@@ -97,7 +107,7 @@ test.group('Lock', () => {
 
   test('run should return callback result', async ({ assert }) => {
     const store = new MemoryStore()
-    const lock = new Lock('foo', store)
+    const lock = new Lock('foo', store, { retry: {}, logger: noopLogger() })
 
     const result = await lock.run(async () => 'foo')
 

packages/verrou/tests/verrou.spec.ts

@@ -41,4 +41,24 @@ test.group('Verrou', () => {
     const lock = verrou.createLock('foo')
     await lock.acquire()
   })
+
+  test('assign custom logger', async ({ assert }) => {
+    const logger = {
+      loggedMessages: [] as any,
+      child: () => logger,
+      log: (level: string, message: any) => logger.loggedMessages.push({ level, message }),
+      trace: (message: any) => logger.log('trace', message),
+      debug: (...args: any[]) => logger.log('debug', args),
+    }
+
+    const verrou = new Verrou({
+      default: 'memory',
+      logger: logger as any,
+      stores: { memory: { driver: memoryStore() } },
+    })
+
+    await verrou.createLock('foo').acquire()
+
+    assert.isAbove(logger.loggedMessages.length, 0)
+  })
 })