Add configurable abort timeout and retries for webhook-caller service

src/app/app.spec.ts

@@ -34,6 +34,12 @@ const mockConfig = async (config) => {
           format: 'simple',
         }
       },
+      makeWebhookProcessorConfig() {
+        return {
+          WEBHOOK_ABORT_TIMEOUT_MS: 10_000,
+          WEBHOOK_MAX_RETRIES: 0,
+        }
+      },
     }
   })
 }

src/app/module.ts

@@ -11,7 +11,11 @@ import { makeJobRunner } from 'lido-nanolib'
 
 import dotenv from 'dotenv'
 
-import { makeConfig, makeLoggerConfig } from '../services/config/service.js'
+import {
+  makeConfig,
+  makeLoggerConfig,
+  makeWebhookProcessorConfig,
+} from '../services/config/service.js'
 import { makeConsensusApi } from '../services/consensus-api/service.js'
 import { makeExecutionApi } from '../services/execution-api/service.js'
 import { makeMetrics, register } from '../services/prom/service.js'
@@ -90,11 +94,9 @@ export const makeAppModule = async () => {
     gsService,
   })
 
-  const webhookProcessor = makeWebhookProcessor(
-    makeRequest([loggerMiddleware(logger), notOkError(), abort(10_000)]),
-    logger,
-    metrics
-  )
+  const webhookConfig = makeWebhookProcessorConfig({ env: process.env })
+
+  const webhookProcessor = makeWebhookProcessor(webhookConfig, logger, metrics)
 
   const messageReloader = makeMessageReloader({
     logger,

src/services/config/service.ts

@@ -113,6 +113,20 @@ export const makeLoggerConfig = ({ env }: { env: NodeJS.ProcessEnv }) => {
   return config
 }
 
+export const makeWebhookProcessorConfig = ({
+  env,
+}: {
+  env: NodeJS.ProcessEnv
+}) => {
+  const config = {
+    WEBHOOK_ABORT_TIMEOUT_MS:
+      optional(() => num(env.WEBHOOK_ABORT_TIMEOUT_MS)) ?? 10_000,
+    WEBHOOK_MAX_RETRIES: optional(() => num(env.WEBHOOK_MAX_RETRIES)) ?? 0,
+  }
+
+  return config
+}
+
 const envOrFile = (env: NodeJS.ProcessEnv, envName: string) => {
   if (env[envName]) return env[envName]
 

src/services/webhook-caller/service.ts

@@ -1,13 +1,31 @@
-import { LoggerService, RequestService } from 'lido-nanolib'
+import {
+  LoggerService,
+  makeRequest,
+  logger as loggerMiddleware,
+  abort,
+  notOkError,
+  retry,
+} from 'lido-nanolib'
 import { MetricsService } from '../prom/service.js'
 
 export type WebhookProcessorService = ReturnType<typeof makeWebhookProcessor>
 
 export const makeWebhookProcessor = (
-  request: RequestService,
+  config: { WEBHOOK_ABORT_TIMEOUT_MS: number; WEBHOOK_MAX_RETRIES: number },
   logger: LoggerService,
   metrics: MetricsService
 ) => {
+  let middlewares = [
+    loggerMiddleware(logger),
+    notOkError(),
+    abort(config.WEBHOOK_ABORT_TIMEOUT_MS),
+  ]
+
+  if (config.WEBHOOK_MAX_RETRIES > 0) {
+    middlewares = [retry(config.WEBHOOK_MAX_RETRIES)].concat(middlewares)
+  }
+
+  const request = makeRequest(middlewares)
   const send = async (
     url: string,
     event: {