fix: removed unused logger in IPRateLimiterService

Signed-off-by: Logan Nguyen <[email protected]>

Author: quiet-node

packages/relay/src/lib/services/rateLimiterService/rateLimiterService.ts

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ConfigService } from '@hashgraph/json-rpc-config-service/dist/services';
-import { Logger } from 'pino';
 import { Counter, Registry } from 'prom-client';
 
 import { RateLimitKey, RateLimitStore } from '../../types';
@@ -12,7 +11,6 @@ import { RequestDetails } from '../../types/RequestDetails';
  */
 export class IPRateLimiterService {
   private store: RateLimitStore;
-  private logger: Logger;
   private ipRateLimitCounter: Counter;
 
   /**
@@ -22,9 +20,8 @@ export class IPRateLimiterService {
    * @param logger - Logger instance for logging.
    * @param register - Prometheus registry for metrics.
    */
-  constructor(store: RateLimitStore, logger: Logger, register: Registry) {
+  constructor(store: RateLimitStore, register: Registry) {
     this.store = store;
-    this.logger = logger;
 
     // Initialize IP rate limit counter
     const ipRateLimitMetricName = 'rpc_relay_ip_rate_limit';

packages/relay/tests/lib/services/rateLimiterService/rateLimiterService.spec.ts

@@ -51,21 +51,21 @@ describe('IPRateLimiterService Test Suite', function () {
   describe('Constructor Tests', () => {
     it('should accept a store and initialize correctly', () => {
       const lruStore = new LruRateLimitStore(duration);
-      rateLimiterService = new IPRateLimiterService(lruStore, logger, registry);
+      rateLimiterService = new IPRateLimiterService(lruStore, registry);
 
       expect(rateLimiterService.rateLimitStore).to.equal(lruStore);
     });
 
     it('should work with LRU store', () => {
       const lruStore = new LruRateLimitStore(duration);
-      rateLimiterService = new IPRateLimiterService(lruStore, logger, registry);
+      rateLimiterService = new IPRateLimiterService(lruStore, registry);
 
       expect(rateLimiterService.rateLimitStore).to.be.instanceof(LruRateLimitStore);
     });
 
     it('should work with Redis store', () => {
       const redisStore = new RedisRateLimitStore(mockRedisClient as unknown as RedisClientType, logger, duration);
-      rateLimiterService = new IPRateLimiterService(redisStore, logger, registry);
+      rateLimiterService = new IPRateLimiterService(redisStore, registry);
 
       expect(rateLimiterService.rateLimitStore).to.be.instanceof(RedisRateLimitStore);
     });
@@ -74,7 +74,7 @@ describe('IPRateLimiterService Test Suite', function () {
   describe('shouldRateLimit Method Tests', () => {
     withOverriddenEnvsInMochaTest({ RATE_LIMIT_DISABLED: true }, () => {
       it('should return false when RATE_LIMIT_DISABLED is true', async () => {
-        rateLimiterService = new IPRateLimiterService(mockStore, logger, registry);
+        rateLimiterService = new IPRateLimiterService(mockStore, registry);
 
         const result = await rateLimiterService.shouldRateLimit(testIp, testMethod, testLimit, requestDetails);
         expect(result).to.be.false;
@@ -87,7 +87,7 @@ describe('IPRateLimiterService Test Suite', function () {
       });
 
       beforeEach(() => {
-        rateLimiterService = new IPRateLimiterService(mockStore, logger, registry);
+        rateLimiterService = new IPRateLimiterService(mockStore, registry);
       });
 
       it('should return false when within rate limits', async () => {
@@ -150,7 +150,7 @@ describe('IPRateLimiterService Test Suite', function () {
 
     beforeEach(() => {
       lruStore = new LruRateLimitStore(duration);
-      rateLimiterService = new IPRateLimiterService(lruStore, logger, registry);
+      rateLimiterService = new IPRateLimiterService(lruStore, registry);
     });
 
     it('should not rate limit when within limits using LRU store', async () => {
@@ -197,7 +197,7 @@ describe('IPRateLimiterService Test Suite', function () {
   describe('Redis Store Integration Tests', () => {
     it('should work with Redis store', () => {
       const redisStore = new RedisRateLimitStore(mockRedisClient as unknown as RedisClientType, logger, duration);
-      rateLimiterService = new IPRateLimiterService(redisStore, logger, registry);
+      rateLimiterService = new IPRateLimiterService(redisStore, registry);
 
       expect(rateLimiterService.rateLimitStore).to.be.instanceof(RedisRateLimitStore);
     });
@@ -209,7 +209,7 @@ describe('IPRateLimiterService Test Suite', function () {
       } as unknown as RedisClientType;
 
       const redisStore = new RedisRateLimitStore(failingMockClient, logger, duration);
-      rateLimiterService = new IPRateLimiterService(redisStore, logger, registry);
+      rateLimiterService = new IPRateLimiterService(redisStore, registry);
 
       // Should not rate limit when Redis operations fail (fail-open behavior)
       const result = await rateLimiterService.shouldRateLimit(testIp, testMethod, testLimit, requestDetails);
@@ -220,7 +220,7 @@ describe('IPRateLimiterService Test Suite', function () {
   // Ensure store.incrementAndCheck is not called when rate limiting is disabled
   withOverriddenEnvsInMochaTest({ RATE_LIMIT_DISABLED: true }, () => {
     it('should not call store.incrementAndCheck when rate limit is disabled', async () => {
-      rateLimiterService = new IPRateLimiterService(mockStore, logger, registry);
+      rateLimiterService = new IPRateLimiterService(mockStore, registry);
       const result = await rateLimiterService.shouldRateLimit(testIp, testMethod, testLimit, requestDetails);
       expect(result).to.be.false;
       expect(mockStore.incrementAndCheck.notCalled).to.be.true;

packages/server/src/koaJsonRpc/index.ts

@@ -19,7 +19,6 @@ import {
   getBatchRequestsEnabled,
   getBatchRequestsMaxSize,
   getDefaultRateLimit,
-  getLimitDuration,
   getRequestIdIsOptional,
 } from './lib/utils';
 
@@ -31,7 +30,6 @@ const BATCH_REQUEST_METHOD_NAME = 'batch_request';
 
 export default class KoaJsonRpc {
   private readonly methodConfig: MethodRateLimitConfiguration;
-  private readonly duration: number = getLimitDuration();
   private readonly defaultRateLimit: number = getDefaultRateLimit();
   private readonly limit: string;
   private readonly rateLimiter: IPRateLimiterService;
@@ -46,13 +44,13 @@ export default class KoaJsonRpc {
     logger: Logger,
     register: Registry,
     relay: Relay,
+    rateLimitStore: RateLimitStore,
     opts?: { limit: string | null },
-    rateLimitStore?: RateLimitStore,
   ) {
     this.koaApp = new Koa();
     this.methodConfig = methodConfiguration;
     this.limit = opts?.limit ?? '1mb';
-    this.rateLimiter = new IPRateLimiterService(rateLimitStore!, logger.child({ name: 'ip-rate-limit' }), register);
+    this.rateLimiter = new IPRateLimiterService(rateLimitStore, register);
     this.metricsRegistry = register;
     this.relay = relay;
 

packages/server/src/server.ts

@@ -160,15 +160,9 @@ export async function initializeServer() {
     redisClient,
   );
 
-  const koaJsonRpc = new KoaJsonRpc(
-    logger.child({ name: 'koa-rpc' }),
-    register,
-    relay,
-    {
-      limit: ConfigService.get('INPUT_SIZE_LIMIT') + 'mb',
-    },
-    rateLimitStore,
-  );
+  const koaJsonRpc = new KoaJsonRpc(logger.child({ name: 'koa-rpc' }), register, relay, rateLimitStore, {
+    limit: ConfigService.get('INPUT_SIZE_LIMIT') + 'mb',
+  });
 
   const app = koaJsonRpc.getKoaApp();
 

packages/server/tests/acceptance/rateLimiter.spec.ts

@@ -46,8 +46,8 @@ describe('@ratelimiter Shared Rate Limiting Acceptance Tests', function () {
     const storeB = new RedisRateLimitStore(redisClient, logger.child({ service: 'B' }), DURATION);
 
     // Create two IPRateLimiterService instances pointing to the same Redis
-    serviceA = new IPRateLimiterService(storeA, logger.child({ service: 'A' }), registryA);
-    serviceB = new IPRateLimiterService(storeB, logger.child({ service: 'B' }), registryB);
+    serviceA = new IPRateLimiterService(storeA, registryA);
+    serviceB = new IPRateLimiterService(storeB, registryB);
   });
 
   after(async function () {

packages/ws-server/src/webSocketServer.ts

@@ -86,7 +86,7 @@ export async function initializeWsServer() {
 
   const mirrorNodeClient = relay.mirrorClient();
 
-  const rateLimiter = new IPRateLimiterService(rateLimitStore, logger.child({ name: 'ip-rate-limit' }), register);
+  const rateLimiter = new IPRateLimiterService(rateLimitStore, register);
   const limiter = new ConnectionLimiter(logger, register, rateLimiter);
   const wsMetricRegistry = new WsMetricRegistry(register);
 
@@ -264,7 +264,7 @@ export async function initializeWsServer() {
     }
   });
 
-  const koaJsonRpc = new KoaJsonRpc(logger, register, relay, undefined, rateLimitStore);
+  const koaJsonRpc = new KoaJsonRpc(logger, register, relay, rateLimitStore, undefined);
   const httpApp = koaJsonRpc.getKoaApp();
   collectDefaultMetrics({ register, prefix: 'rpc_relay_' });
 

packages/ws-server/tests/acceptance/rateLimiter.spec.ts

@@ -47,8 +47,8 @@ describe('@web-socket-ratelimiter Shared Rate Limiting Acceptance Tests', functi
     const storeB = new RedisRateLimitStore(redisClient, logger.child({ service: 'WS-B' }), DURATION);
 
     // Create two IPRateLimiterService instances for WebSocket servers pointing to the same Redis
-    wsServiceA = new IPRateLimiterService(storeA, logger.child({ service: 'WS-A' }), registryA);
-    wsServiceB = new IPRateLimiterService(storeB, logger.child({ service: 'WS-B' }), registryB);
+    wsServiceA = new IPRateLimiterService(storeA, registryA);
+    wsServiceB = new IPRateLimiterService(storeB, registryB);
   });
 
   after(async function () {

packages/ws-server/tests/unit/connectionLimiter.spec.ts

@@ -70,7 +70,7 @@ describe('Connection Limiter', function () {
     const mockStore = {
       incrementAndCheck: sinon.stub().resolves(false),
     };
-    const rateLimiter = new IPRateLimiterService(mockStore as any, mockLogger, mockRegistry);
+    const rateLimiter = new IPRateLimiterService(mockStore as any, mockRegistry);
 
     rateLimiterStub = sinon.stub(IPRateLimiterService.prototype, 'shouldRateLimit');
     connectionLimiter = new ConnectionLimiter(mockLogger, mockRegistry, rateLimiter);