Register own listener for errors

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v4.1.0 2019-08-06
+
+- Safe limiter registers own listener for `error` event so errors are ignored
+  by default.
+
 ## v4.0.0 2019-07-11
 
 - Breaking change: `interval` parameter is milliseconds now.

src/safe-redis-sliding-window-rate-limiter.ts

@@ -27,7 +27,7 @@ export interface SafeRedisSlidingWindowRateLimiter {
 
 export class SafeRedisSlidingWindowRateLimiter extends RedisSlidingWindowRateLimiter
   implements SlidingWindowRateLimiterBackend {
-  readonly reuseRedisAfter: number
+  readonly reuseRedisAfter = Number(this.options.reuseRedisAfter) || 2000
 
   private redisServiceAvailable = true
 
@@ -36,8 +36,7 @@ export class SafeRedisSlidingWindowRateLimiter extends RedisSlidingWindowRateLim
 
   constructor(readonly options: SafeRedisSlidingWindowRateLimiterOptions = {}) {
     super(options)
-
-    this.reuseRedisAfter = Number(options.reuseRedisAfter) || 2000
+    this.on("error", this.errorHandler)
   }
 
   cancel(key: string, token: number): Promise<CancelResult> {
@@ -90,6 +89,10 @@ export class SafeRedisSlidingWindowRateLimiter extends RedisSlidingWindowRateLim
     this.removeAllListeners("error")
   }
 
+  private errorHandler(_error: Error): void {
+    // ignore
+  }
+
   private handleError(error: Error): void {
     this.markServiceAsUnavailable()
     this.emit("error", error)

test/redis-failure.ts

@@ -7,7 +7,7 @@ import {CheckResult, Redis, ReserveResult, SafeRedisSlidingWindowRateLimiter} fr
 import {MockIORedis} from "./lib/mock-ioredis"
 
 Feature("Test sliding-window-rate-limiter Redis failure with safe backend", () => {
-  Scenario("Redis failure", () => {
+  Scenario("Redis failure with error listener", () => {
     const defaultLimit = 1
     const errors: Error[] = []
 
@@ -66,4 +66,49 @@ Feature("Test sliding-window-rate-limiter Redis failure with safe backend", () =
       expect(errors.length).to.equal(1)
     })
   })
+
+  Scenario("Redis failure without error listener", () => {
+    const defaultLimit = 1
+
+    let checkResult: CheckResult
+    let key: string
+    let limiter: SafeRedisSlidingWindowRateLimiter
+    let redis: Redis
+    let reserveResult: ReserveResult
+
+    Given("redis connection", () => {
+      redis = new MockIORedis()
+    })
+
+    And("limiter object", () => {
+      limiter = new SafeRedisSlidingWindowRateLimiter({
+        interval: 1,
+        redis,
+      })
+    })
+
+    And("key", () => {
+      key = "redis-failure:" + uuidv1()
+    })
+
+    When("Redis is disconnected", () => {
+      redis.disconnect()
+    })
+
+    And("check method is called", async () => {
+      checkResult = await limiter.check(key, defaultLimit)
+    })
+
+    Then("usage is 0", async () => {
+      expect(checkResult.usage).to.equal(0)
+    })
+
+    When("reserve method is called", async () => {
+      reserveResult = await limiter.reserve(key, defaultLimit)
+    })
+
+    Then("usage is 0", async () => {
+      expect(reserveResult.usage).to.equal(0)
+    })
+  })
 })