@lota-sdk/core 0.4.7 → 0.4.9

package/src/redis/connection.ts

@@ -1,6 +1,9 @@
+import { Duration, Effect, Exit, Fiber } from 'effect'
 import IORedis from 'ioredis'
 import type { RedisOptions } from 'ioredis'
 
+import { ConfigurationError } from '../effect/errors'
+import { effectTryServicePromise } from '../effect/helpers'
 import { getErrorMessage } from '../utils/errors'
 
 export interface RedisConnectionLogger {
@@ -10,7 +13,7 @@ export interface RedisConnectionLogger {
   error?: (message: string) => void
 }
 
-interface CreateRedisConnectionManagerOptions {
+export interface CreateRedisConnectionManagerOptions {
   url: string
   redisOptions?: RedisOptions
   healthCheckIntervalMs?: number
@@ -29,6 +32,8 @@ const REDIS_RETRY_STEP_MS = 50
 const REDIS_RETRY_MAX_DELAY_MS = 2000
 const REDIS_CONNECT_TIMEOUT_MS = 10_000
 
+type HealthCheckFiber = ReturnType<typeof Effect.runFork>
+
 export const DEFAULT_REDIS_OPTIONS: RedisOptions = {
   maxRetriesPerRequest: null,
   enableReadyCheck: true,
@@ -55,10 +60,11 @@ function log(logger: RedisConnectionLogger | undefined, level: keyof RedisConnec
 class RedisConnectionManagerImpl implements RedisConnectionManager {
   private redis: IORedis | null = null
   private isHealthy = false
-  private healthCheckInterval: ReturnType<typeof setInterval> | null = null
   private isInitialized = false
   private isClosing = false
   private isHealthCheckRunning = false
+  private healthChecksActive = false
+  private healthCheckFiber: HealthCheckFiber | null = null
 
   constructor(private readonly options: CreateRedisConnectionManagerOptions) {
     this.initializeConnection()
@@ -123,32 +129,70 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
   }
 
   private startHealthChecks(): void {
-    if (this.healthCheckInterval) {
+    if (this.healthChecksActive || this.healthCheckFiber) {
       return
     }
 
+    this.healthChecksActive = true
     const intervalMs = this.options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
-    this.healthCheckInterval = setInterval(async () => {
-      if (this.isHealthCheckRunning) return
-      this.isHealthCheckRunning = true
-      try {
-        if (this.redis && this.redis.status === 'ready') {
-          await this.redis.ping()
-          this.isHealthy = true
+    const logger = this.options.logger
+    const isHealthChecksActive = () => this.healthChecksActive
+    const isHealthCheckRunning = () => this.isHealthCheckRunning
+    const setHealthCheckRunning = (value: boolean) => {
+      this.isHealthCheckRunning = value
+    }
+    const getRedis = () => this.redis
+    const setHealthy = (value: boolean) => {
+      this.isHealthy = value
+    }
+
+    this.healthCheckFiber = Effect.runFork(
+      Effect.gen(function* () {
+        for (;;) {
+          yield* Effect.sleep(Duration.millis(intervalMs))
+          if (!isHealthChecksActive()) break
+          if (isHealthCheckRunning()) continue
+
+          setHealthCheckRunning(true)
+          try {
+            const redis = getRedis()
+            if (redis && redis.status === 'ready') {
+              const pingExit = yield* Effect.exit(
+                effectTryServicePromise(() => redis.ping(), 'Redis health check failed'),
+              )
+              if (Exit.isFailure(pingExit)) {
+                log(logger, 'warn', `Redis health check failed: ${getErrorMessage(pingExit.cause)}`)
+                setHealthy(false)
+              } else {
+                setHealthy(true)
+              }
+            }
+          } finally {
+            setHealthCheckRunning(false)
+          }
         }
-      } catch (error) {
-        log(this.options.logger, 'warn', `Redis health check failed: ${getErrorMessage(error)}`)
-        this.isHealthy = false
-      } finally {
-        this.isHealthCheckRunning = false
-      }
-    }, intervalMs)
-    this.healthCheckInterval.unref()
+      }),
+    )
+  }
+
+  private stopHealthChecks(): Promise<void> {
+    this.healthChecksActive = false
+
+    const fiber = this.healthCheckFiber
+    if (!fiber) {
+      return Promise.resolve()
+    }
+
+    this.healthCheckFiber = null
+    return Effect.runPromise(Fiber.interrupt(fiber)).then(
+      () => undefined,
+      () => undefined,
+    )
   }
 
   getConnection(): IORedis {
     if (!this.redis) {
-      throw new Error('Redis connection not initialized')
+      throw new ConfigurationError({ message: 'Redis connection not initialized', key: 'redis' })
     }
     return this.redis
   }
@@ -161,22 +205,30 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
     return this.isHealthy && this.redis?.status === 'ready'
   }
 
-  async closeConnection(): Promise<void> {
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval)
-      this.healthCheckInterval = null
-    }
-
+  closeConnection(): Promise<void> {
     this.isClosing = true
-
-    try {
-      if (this.redis && this.redis.status !== 'end') {
-        await this.redis.quit()
-      }
-    } catch (error) {
-      log(this.options.logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(error)}`)
+    const logger = this.options.logger
+    const getRedis = () => this.redis
+    const stopHealthChecks = () => this.stopHealthChecks()
+    const disconnect = () => {
       this.redis?.disconnect()
     }
+
+    return Effect.runPromise(
+      Effect.gen(function* () {
+        yield* Effect.tryPromise(() => stopHealthChecks())
+        const redis = getRedis()
+        if (redis && redis.status !== 'end') {
+          const quitExit = yield* Effect.exit(
+            effectTryServicePromise(() => redis.quit(), 'Failed to close Redis connection manager'),
+          )
+          if (Exit.isFailure(quitExit)) {
+            log(logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(quitExit.cause)}`)
+            disconnect()
+          }
+        }
+      }),
+    )
   }
 }
 

package/src/redis/index.ts

@@ -1,15 +1,13 @@
 import { createRedisConnectionManager } from './connection'
 import type { RedisConnectionManager } from './connection'
 export { DEFAULT_REDIS_OPTIONS, type RedisConnectionLogger } from './connection'
+export { withOrgMemoryLock, withOrgMemoryLockEffect } from './org-memory-lock'
+export { withLeaseLock } from './redis-lease-lock'
 export {
-  getRedisConnection,
-  getRedisConnectionForBullMQ,
-  setRedisConnectionManager,
-  type RedisConnectionAccessor,
-} from './connection-accessor'
-export { withOrgMemoryLock } from './org-memory-lock'
-export { LeaseLockLostError, withRedisLeaseLock } from './redis-lease-lock'
-export { closeSharedSubscriber, createThreadResumableContext } from './stream-context'
+  createThreadResumableContext,
+  SharedThreadStreamSubscriberLive,
+  SharedThreadStreamSubscriberTag,
+} from './stream-context'
 
 export { createRedisConnectionManager }
 export type { RedisConnectionManager }

package/src/redis/org-memory-lock.ts

@@ -1,6 +1,12 @@
+import { Schema, Effect } from 'effect'
+import type IORedis from 'ioredis'
+
 import { serverLogger } from '../config/logger'
-import { getRedisConnection } from './connection-accessor'
-import { withRedisLeaseLock } from './redis-lease-lock'
+import { LockAcquisitionError } from '../effect/errors'
+import type { LockLostError, RedisError } from '../effect/errors'
+import { withLeaseLock } from './redis-lease-lock'
+import type { RedisLeaseLockOptions } from './redis-lease-lock'
+import { getRuntimeRedisConnection } from './runtime-connection'
 
 const ORG_MEMORY_LOCK_PREFIX = 'lock:org-memory:org:'
 const ORG_MEMORY_LOCK_TTL_MS = 120_000
@@ -9,35 +15,62 @@ const ORG_MEMORY_LOCK_REFRESH_INTERVAL_MS = 30_000
 const ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS = 30_000
 const ORG_MEMORY_LOCK_MAX_WAIT_MS = 15 * 60 * 1000
 
-export async function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+class OrgMemoryLockCallbackError extends Schema.TaggedErrorClass<OrgMemoryLockCallbackError>()(
+  'OrgMemoryLockCallbackError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
+function createOrgMemoryLockOptions(redis: IORedis, orgId: string): RedisLeaseLockOptions & { redis: IORedis } {
+  return {
+    redis,
+    lockKey: `${ORG_MEMORY_LOCK_PREFIX}${orgId}`,
+    lockTtlMs: ORG_MEMORY_LOCK_TTL_MS,
+    retryDelayMs: ORG_MEMORY_LOCK_RETRY_DELAY_MS,
+    refreshIntervalMs: ORG_MEMORY_LOCK_REFRESH_INTERVAL_MS,
+    waitLogIntervalMs: ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS,
+    maxWaitMs: ORG_MEMORY_LOCK_MAX_WAIT_MS,
+    label: 'org memory lock',
+    logger: {
+      debug: (message) => {
+        serverLogger.debug`${message}`
+      },
+      info: (message) => {
+        serverLogger.info`${message}`
+      },
+      warn: (message) => {
+        serverLogger.warn`${message}`
+      },
+    },
+  }
+}
+
+export function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+  return Effect.runPromise(
+    withOrgMemoryLockEffect(orgId, (signal) =>
+      Effect.tryPromise({
+        try: () => fn(signal),
+        catch: (cause) => new OrgMemoryLockCallbackError({ message: 'Org memory lock callback failed.', cause }),
+      }),
+    ),
+  )
+}
+
+export function withOrgMemoryLockEffect<A, E>(
+  orgId: string,
+  fn: (signal: AbortSignal) => Effect.Effect<A, E>,
+): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError> {
   const normalizedOrgId = orgId.trim()
 
   if (!normalizedOrgId) {
-    throw new Error('Organization id is required for memory lock')
+    return Effect.fail(
+      new LockAcquisitionError({
+        lockKey: `${ORG_MEMORY_LOCK_PREFIX}<missing-org-id>`,
+        maxWaitMs: ORG_MEMORY_LOCK_MAX_WAIT_MS,
+      }),
+    )
   }
 
-  return withRedisLeaseLock(
-    {
-      redis: getRedisConnection(),
-      lockKey: `${ORG_MEMORY_LOCK_PREFIX}${normalizedOrgId}`,
-      lockTtlMs: ORG_MEMORY_LOCK_TTL_MS,
-      retryDelayMs: ORG_MEMORY_LOCK_RETRY_DELAY_MS,
-      refreshIntervalMs: ORG_MEMORY_LOCK_REFRESH_INTERVAL_MS,
-      waitLogIntervalMs: ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS,
-      maxWaitMs: ORG_MEMORY_LOCK_MAX_WAIT_MS,
-      label: 'org memory lock',
-      logger: {
-        debug: (message) => {
-          serverLogger.debug`${message}`
-        },
-        info: (message) => {
-          serverLogger.info`${message}`
-        },
-        warn: (message) => {
-          serverLogger.warn`${message}`
-        },
-      },
-    },
-    fn,
+  return Effect.sync(() => getRuntimeRedisConnection()).pipe(
+    Effect.flatMap((redis) => withLeaseLock(createOrgMemoryLockOptions(redis, normalizedOrgId), fn)),
   )
 }

package/src/redis/redis-lease-lock.ts

@@ -1,7 +1,8 @@
-import { setTimeout as delay } from 'node:timers/promises'
-
+import { Clock, Deferred, Duration, Effect, Random, Schedule } from 'effect'
 import type IORedis from 'ioredis'
 
+import { LockAcquisitionError, LockLostError, RedisError } from '../effect/errors'
+import { RedisServiceTag } from '../effect/services'
 import { getErrorMessage } from '../utils/errors'
 
 interface RedisLeaseLockLogger {
@@ -10,8 +11,8 @@ interface RedisLeaseLockLogger {
   warn?: (message: string) => void
 }
 
-interface RedisLeaseLockOptions {
-  redis: IORedis
+export interface RedisLeaseLockOptions {
+  redis?: IORedis
   lockKey: string
   lockTtlMs: number
   retryDelayMs?: number
@@ -47,144 +48,222 @@ function log(logger: RedisLeaseLockLogger | undefined, level: keyof RedisLeaseLo
   }
 }
 
-async function acquireLeaseLock(
-  options: Required<Pick<RedisLeaseLockOptions, 'retryDelayMs' | 'waitLogIntervalMs' | 'maxWaitMs'>> &
-    RedisLeaseLockOptions & { lockValue: string; label: string },
-): Promise<void> {
-  const waitStart = Date.now()
-  let lastWaitLogAt = waitStart
-
-  for (;;) {
-    const result = await options.redis.set(options.lockKey, options.lockValue, 'PX', options.lockTtlMs, 'NX')
-
-    if (result === 'OK') {
-      return
-    }
+function toRedisError(error: unknown, message: string): RedisError {
+  return new RedisError({ message: `${message}: ${getErrorMessage(error)}`, cause: error })
+}
 
-    const now = Date.now()
-    const waitedMs = now - waitStart
-    if (waitedMs >= options.maxWaitMs) {
-      throw new Error(`Timed out waiting for ${options.label} (${options.lockKey}) waitedMs=${waitedMs}`)
-    }
+function getNormalizedOptions(options: RedisLeaseLockOptions) {
+  const normalizedLockTtlMs = Math.max(1_000, Math.trunc(options.lockTtlMs))
+  const requestedRefreshIntervalMs = options.refreshIntervalMs ?? Math.floor(normalizedLockTtlMs / 3)
+  const normalizedRefreshIntervalMs = Math.min(
+    Math.max(250, Math.trunc(requestedRefreshIntervalMs)),
+    Math.max(250, normalizedLockTtlMs - 250),
+  )
 
-    if (now - lastWaitLogAt >= options.waitLogIntervalMs) {
-      log(options.logger, 'info', `Waiting for ${options.label} (${options.lockKey}) waitedMs=${waitedMs}`)
-      lastWaitLogAt = now
-    }
+  return {
+    ...options,
+    lockKey: options.lockKey.trim(),
+    lockTtlMs: normalizedLockTtlMs,
+    retryDelayMs: options.retryDelayMs ?? 500,
+    refreshIntervalMs: normalizedRefreshIntervalMs,
+    waitLogIntervalMs: options.waitLogIntervalMs ?? 30_000,
+    maxWaitMs: options.maxWaitMs ?? 45_000,
+    acquiredWaitInfoThresholdMs: options.acquiredWaitInfoThresholdMs ?? 1_000,
+    heldInfoThresholdMs: options.heldInfoThresholdMs ?? 5_000,
+    label: options.label ?? 'redis lease lock',
+  }
+}
 
-    await delay(options.retryDelayMs)
+function resolveRedisConnection(options: RedisLeaseLockOptions): Effect.Effect<IORedis, RedisError, RedisServiceTag> {
+  if (options.redis) {
+    return Effect.succeed(options.redis)
   }
+
+  return Effect.gen(function* () {
+    const redisService = yield* RedisServiceTag
+    return redisService.getConnection()
+  })
 }
 
-async function refreshLeaseLock(options: RedisLeaseLockOptions & { lockValue: string; label: string }): Promise<void> {
-  const refreshed = await options.redis.eval(
-    REFRESH_LOCK_SCRIPT,
-    1,
-    options.lockKey,
-    options.lockValue,
-    options.lockTtlMs.toString(),
-  )
+function acquireLock(
+  redis: IORedis,
+  options: ReturnType<typeof getNormalizedOptions>,
+  lockValue: string,
+): Effect.Effect<void, LockAcquisitionError | RedisError> {
+  return Effect.gen(function* () {
+    const waitStart = yield* Clock.currentTimeMillis
+    let lastWaitLogAt = waitStart
 
-  const refreshedCount = typeof refreshed === 'number' ? refreshed : Number(refreshed)
-  if (refreshedCount === 1) return
-  throw new Error(`${options.label} refresh was rejected for key ${options.lockKey}`)
+    const tryOnce = Effect.gen(function* () {
+      const result = yield* Effect.tryPromise({
+        try: () => redis.set(options.lockKey, lockValue, 'PX', options.lockTtlMs, 'NX'),
+        catch: (error) => toRedisError(error, `Failed to acquire ${options.label} (${options.lockKey})`),
+      })
+
+      if (result === 'OK') {
+        return
+      }
+
+      const now = yield* Clock.currentTimeMillis
+      const waitedMs = now - waitStart
+      if (now - lastWaitLogAt >= options.waitLogIntervalMs) {
+        log(options.logger, 'info', `Waiting for ${options.label} (${options.lockKey}) waitedMs=${waitedMs}`)
+        lastWaitLogAt = now
+      }
+
+      return yield* new LockAcquisitionError({ lockKey: options.lockKey, maxWaitMs: options.maxWaitMs })
+    })
+
+    return yield* Effect.retry(tryOnce, {
+      times: Math.max(0, Math.ceil(options.maxWaitMs / options.retryDelayMs) - 1),
+      schedule: Schedule.fixed(Duration.millis(options.retryDelayMs)),
+    }).pipe(
+      Effect.asVoid,
+      Effect.catchTag('LockAcquisitionError', () =>
+        Effect.fail(new LockAcquisitionError({ lockKey: options.lockKey, maxWaitMs: options.maxWaitMs })),
+      ),
+    )
+  })
 }
 
-async function releaseLeaseLock(options: RedisLeaseLockOptions & { lockValue: string }): Promise<void> {
-  await options.redis.eval(RELEASE_LOCK_SCRIPT, 1, options.lockKey, options.lockValue)
+function refreshLock(
+  redis: IORedis,
+  options: ReturnType<typeof getNormalizedOptions>,
+  lockValue: string,
+): Effect.Effect<void, LockLostError | RedisError> {
+  return Effect.tryPromise({
+    try: () => redis.eval(REFRESH_LOCK_SCRIPT, 1, options.lockKey, lockValue, options.lockTtlMs.toString()),
+    catch: (error) => toRedisError(error, `Failed to refresh ${options.label} (${options.lockKey})`),
+  }).pipe(
+    Effect.flatMap((refreshed) => {
+      const refreshedCount = typeof refreshed === 'number' ? refreshed : Number(refreshed)
+      if (refreshedCount === 1) {
+        return Effect.void
+      }
+      return Effect.fail(new LockLostError({ lockKey: options.lockKey }))
+    }),
+  )
 }
 
-export class LeaseLockLostError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'LeaseLockLostError'
-  }
+function releaseLock(
+  redis: IORedis,
+  options: ReturnType<typeof getNormalizedOptions>,
+  lockValue: string,
+): Effect.Effect<void, RedisError> {
+  return Effect.asVoid(
+    Effect.tryPromise({
+      try: () => redis.eval(RELEASE_LOCK_SCRIPT, 1, options.lockKey, lockValue),
+      catch: (error) => toRedisError(error, `Failed to release ${options.label} (${options.lockKey})`),
+    }),
+  )
 }
 
-function startLeaseLockRefreshLoop(
-  options: Required<Pick<RedisLeaseLockOptions, 'refreshIntervalMs'>> &
-    RedisLeaseLockOptions & { lockValue: string; label: string },
-  ac: AbortController,
-): () => void {
-  let stopped = false
-
-  const timer = setInterval(() => {
-    if (stopped) return
-    void refreshLeaseLock(options).catch((error: unknown) => {
-      stopped = true
-      clearInterval(timer)
-      const message = `Failed to refresh ${options.label} (${options.lockKey}): ${getErrorMessage(error)}`
-      log(options.logger, 'warn', message)
-      if (!ac.signal.aborted) {
-        ac.abort(new LeaseLockLostError(message))
-      }
-    })
-  }, options.refreshIntervalMs)
+function startRefreshFiber(
+  redis: IORedis,
+  options: ReturnType<typeof getNormalizedOptions>,
+  lockValue: string,
+  abortController: AbortController,
+  lockLost: Deferred.Deferred<never, LockLostError | RedisError>,
+) {
+  const handleLockLoss = (error: LockLostError | RedisError) =>
+    Deferred.fail(lockLost, error).pipe(
+      Effect.andThen(
+        Effect.sync(() => {
+          const message =
+            error._tag === 'LockLostError'
+              ? `${options.label} refresh was rejected for key ${options.lockKey}`
+              : error.message
 
-  timer.unref()
+          log(options.logger, 'warn', message)
+          if (!abortController.signal.aborted) {
+            abortController.abort(error)
+          }
+        }),
+      ),
+      Effect.andThen(Effect.fail(error)),
+    )
 
-  return () => {
-    stopped = true
-    clearInterval(timer)
-  }
+  const refreshProgram = Effect.gen(function* () {
+    for (;;) {
+      yield* Effect.sleep(Duration.millis(options.refreshIntervalMs))
+
+      yield* refreshLock(redis, options, lockValue).pipe(
+        Effect.catchTag('LockLostError', handleLockLoss),
+        Effect.catchTag('RedisError', handleLockLoss),
+      )
+    }
+  })
+
+  return Effect.forkScoped(refreshProgram).pipe(Effect.asVoid)
 }
 
-export async function withRedisLeaseLock<T>(
+export function withLeaseLock<A, E, R>(
+  options: RedisLeaseLockOptions & { redis: IORedis },
+  fn: (signal: AbortSignal) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError, R>
+export function withLeaseLock<A, E, R>(
   options: RedisLeaseLockOptions,
-  fn: (signal: AbortSignal) => Promise<T>,
-): Promise<T> {
-  const lockKey = options.lockKey.trim()
-  if (!lockKey) {
-    throw new Error('Redis lease lock requires a non-empty lock key')
-  }
+  fn: (signal: AbortSignal) => Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError, RedisServiceTag | R> {
+  const normalized = getNormalizedOptions(options)
 
-  const retryDelayMs = options.retryDelayMs ?? 500
-  const refreshIntervalMs = options.refreshIntervalMs ?? 30_000
-  const waitLogIntervalMs = options.waitLogIntervalMs ?? 30_000
-  const maxWaitMs = options.maxWaitMs ?? 45_000
-  const acquiredWaitInfoThresholdMs = options.acquiredWaitInfoThresholdMs ?? 1_000
-  const heldInfoThresholdMs = options.heldInfoThresholdMs ?? 5_000
-  const label = options.label ?? 'redis lease lock'
-
-  const lockValue = crypto.randomUUID()
-  const waitStart = Date.now()
-  await acquireLeaseLock({ ...options, lockKey, lockValue, label, retryDelayMs, waitLogIntervalMs, maxWaitMs })
-  const waitedMs = Date.now() - waitStart
-  if (waitedMs >= acquiredWaitInfoThresholdMs) {
-    log(options.logger, 'info', `Acquired ${label} (${lockKey}) after waiting waitedMs=${waitedMs}`)
-  }
+  return Effect.gen(function* () {
+    if (!normalized.lockKey) {
+      return yield* new LockAcquisitionError({ lockKey: '', maxWaitMs: normalized.maxWaitMs })
+    }
 
-  const ac = new AbortController()
-  const stopRefreshLoop = startLeaseLockRefreshLoop({ ...options, lockKey, lockValue, label, refreshIntervalMs }, ac)
-  const holdStart = Date.now()
+    const redis = yield* resolveRedisConnection(options)
+    const lockValue = yield* Random.nextUUIDv4
+    const waitStart = yield* Clock.currentTimeMillis
 
-  try {
-    const abortPromise = new Promise<never>((_, reject) => {
-      if (ac.signal.aborted) {
-        reject(ac.signal.reason as Error)
-        return
-      }
-      ac.signal.addEventListener(
-        'abort',
-        () => {
-          reject(ac.signal.reason as Error)
-        },
-        { once: true },
+    yield* acquireLock(redis, normalized, lockValue)
+
+    const waitedMs = (yield* Clock.currentTimeMillis) - waitStart
+    if (waitedMs >= normalized.acquiredWaitInfoThresholdMs) {
+      log(
+        normalized.logger,
+        'info',
+        `Acquired ${normalized.label} (${normalized.lockKey}) after waiting waitedMs=${waitedMs}`,
       )
-    })
-    return await Promise.race([fn(ac.signal), abortPromise])
-  } finally {
-    stopRefreshLoop()
-    const heldMs = Date.now() - holdStart
-    if (!ac.signal.aborted) {
-      await releaseLeaseLock({ ...options, lockKey, lockValue }).catch((error: unknown) => {
-        log(options.logger, 'warn', `Failed to release ${label} (${lockKey}): ${getErrorMessage(error)}`)
-      })
-    }
-    if (heldMs >= heldInfoThresholdMs) {
-      log(options.logger, 'info', `Released ${label} (${lockKey}) heldMs=${heldMs}`)
-    } else {
-      log(options.logger, 'debug', `Released ${label} (${lockKey}) heldMs=${heldMs}`)
     }
-  }
+
+    const abortController = new AbortController()
+    const holdStart = yield* Clock.currentTimeMillis
+    const lockLost = yield* Deferred.make<never, LockLostError | RedisError>()
+
+    const cleanup = Effect.sync(() => {
+      if (!abortController.signal.aborted) {
+        abortController.abort()
+      }
+    }).pipe(
+      Effect.andThen(
+        releaseLock(redis, normalized, lockValue).pipe(
+          Effect.catch((error) =>
+            Effect.sync(() => {
+              log(normalized.logger, 'warn', error.message)
+            }),
+          ),
+        ),
+      ),
+      Effect.andThen(
+        Effect.gen(function* () {
+          const heldMs = (yield* Clock.currentTimeMillis) - holdStart
+          if (heldMs >= normalized.heldInfoThresholdMs) {
+            log(normalized.logger, 'info', `Released ${normalized.label} (${normalized.lockKey}) heldMs=${heldMs}`)
+            return
+          }
+
+          log(normalized.logger, 'debug', `Released ${normalized.label} (${normalized.lockKey}) heldMs=${heldMs}`)
+        }),
+      ),
+      Effect.ignore,
+    )
+
+    return yield* Effect.scoped(
+      startRefreshFiber(redis, normalized, lockValue, abortController, lockLost).pipe(
+        Effect.andThen(fn(abortController.signal).pipe(Effect.raceFirst(Deferred.await(lockLost)))),
+        Effect.ensuring(cleanup),
+      ),
+    )
+  })
 }

package/src/redis/runtime-connection.ts

@@ -0,0 +1,10 @@
+import { Effect } from 'effect'
+import type IORedis from 'ioredis'
+
+import { getCurrentRuntime } from '../effect/runtime-ref'
+import { RedisServiceTag } from '../effect/services'
+
+export function getRuntimeRedisConnection(): IORedis {
+  const redis = getCurrentRuntime().runSync(Effect.service(RedisServiceTag))
+  return redis.getConnection()
+}