@prosopo/provider 4.12.0 → 4.13.1

package/dist/cjs/api/metrics.cjs

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const promClient = require("prom-client");
+const metricsEnabled = () => process.env.PROSOPO_METRICS_ENABLED !== "false";
+const PREFIX = "prosopo_";
+const LATENCY_BUCKETS = [
+  5e-3,
+  0.01,
+  0.025,
+  0.05,
+  0.1,
+  0.25,
+  0.5,
+  1,
+  2.5,
+  5,
+  10
+];
+const SCORE_BUCKETS = [
+  0,
+  0.1,
+  0.2,
+  0.3,
+  0.4,
+  0.5,
+  0.6,
+  0.7,
+  0.8,
+  0.9,
+  1,
+  1.5,
+  2,
+  3,
+  5,
+  10
+];
+const KNOWN_ROUTES = /* @__PURE__ */ new Set([
+  ...Object.values(types.ClientApiPaths),
+  ...Object.values(types.PublicApiPaths),
+  ...Object.values(types.AdminApiPaths)
+]);
+const normaliseRoute = (req) => {
+  const path = req.path;
+  return KNOWN_ROUTES.has(path) ? path : "other";
+};
+let metrics;
+const buildMetrics = () => {
+  const registry = new promClient.Registry();
+  promClient.collectDefaultMetrics({ register: registry, prefix: PREFIX });
+  const httpRequestsTotal = new promClient.Counter({
+    name: `${PREFIX}http_requests_total`,
+    help: "Total HTTP requests handled by the provider API",
+    labelNames: ["route", "method", "status"],
+    registers: [registry]
+  });
+  const httpRequestDuration = new promClient.Histogram({
+    name: `${PREFIX}http_request_duration_seconds`,
+    help: "Provider API request duration in seconds",
+    labelNames: ["route", "method", "status"],
+    buckets: LATENCY_BUCKETS,
+    registers: [registry]
+  });
+  const captchaIssuedTotal = new promClient.Counter({
+    name: `${PREFIX}captcha_issued_total`,
+    help: "Captcha challenges issued, by type",
+    labelNames: ["type"],
+    registers: [registry]
+  });
+  const captchaIssueErrorsTotal = new promClient.Counter({
+    name: `${PREFIX}captcha_issue_errors_total`,
+    help: "Errors while issuing captcha challenges, by type",
+    labelNames: ["type"],
+    registers: [registry]
+  });
+  const captchaVerifyTotal = new promClient.Counter({
+    name: `${PREFIX}captcha_verify_total`,
+    help: "Captcha verification outcomes, by type/result/source",
+    labelNames: ["type", "result", "source"],
+    registers: [registry]
+  });
+  const frictionlessRoutedTotal = new promClient.Counter({
+    name: `${PREFIX}frictionless_routed_total`,
+    help: "Frictionless routing decisions (which captcha the user was sent to)",
+    labelNames: ["decision"],
+    registers: [registry]
+  });
+  const botScore = new promClient.Histogram({
+    name: `${PREFIX}bot_score`,
+    help: "Distribution of frictionless bot scores (0=human .. 1=bot; language-rule penalties can push it above 1)",
+    buckets: SCORE_BUCKETS,
+    registers: [registry]
+  });
+  const detectorTriggeredTotal = new promClient.Counter({
+    name: `${PREFIX}detector_triggered_total`,
+    help: "Count of times each bot detector was triggered",
+    labelNames: ["detector"],
+    registers: [registry]
+  });
+  const blockedRequestsTotal = new promClient.Counter({
+    name: `${PREFIX}blocked_requests_total`,
+    help: "Requests blocked before reaching a captcha handler, by reason",
+    labelNames: ["reason"],
+    registers: [registry]
+  });
+  const domainValidationTotal = new promClient.Counter({
+    name: `${PREFIX}domain_validation_total`,
+    help: "Domain/site-key validation outcomes",
+    labelNames: ["result"],
+    registers: [registry]
+  });
+  const spamEmailTotal = new promClient.Counter({
+    name: `${PREFIX}spam_email_total`,
+    help: "Spam email-domain check outcomes",
+    labelNames: ["result"],
+    registers: [registry]
+  });
+  const maintenanceMode = new promClient.Gauge({
+    name: `${PREFIX}maintenance_mode`,
+    help: "1 when the provider is in maintenance mode, else 0",
+    registers: [registry]
+  });
+  maintenanceMode.set(
+    process.env.MAINTENANCE_MODE?.toLowerCase() === "true" ? 1 : 0
+  );
+  const redisReady = new promClient.Gauge({
+    name: `${PREFIX}redis_ready`,
+    help: "1 when the given redis connection is ready, else 0",
+    labelNames: ["actor"],
+    registers: [registry]
+  });
+  return {
+    registry,
+    httpRequestsTotal,
+    httpRequestDuration,
+    captchaIssuedTotal,
+    captchaIssueErrorsTotal,
+    captchaVerifyTotal,
+    frictionlessRoutedTotal,
+    botScore,
+    detectorTriggeredTotal,
+    blockedRequestsTotal,
+    domainValidationTotal,
+    spamEmailTotal,
+    maintenanceMode,
+    redisReady
+  };
+};
+const getMetrics = () => {
+  if (!metrics) {
+    metrics = buildMetrics();
+  }
+  return metrics;
+};
+const recordCaptchaIssued = (type) => {
+  if (!metricsEnabled()) return;
+  getMetrics().captchaIssuedTotal.inc({ type });
+};
+const recordCaptchaIssueError = (type) => {
+  if (!metricsEnabled()) return;
+  getMetrics().captchaIssueErrorsTotal.inc({ type });
+};
+const recordCaptchaVerify = (args) => {
+  if (!metricsEnabled()) return;
+  getMetrics().captchaVerifyTotal.inc({
+    type: args.type,
+    result: args.verified ? "verified" : "failed",
+    source: args.source
+  });
+};
+const recordFrictionlessDecision = (decision) => {
+  if (!metricsEnabled()) return;
+  getMetrics().frictionlessRoutedTotal.inc({ decision });
+};
+const recordBotScore = (score) => {
+  if (!metricsEnabled()) return;
+  getMetrics().botScore.observe(score);
+};
+const recordDetectorTriggered = (detectors) => {
+  if (!metricsEnabled()) return;
+  const m = getMetrics();
+  for (const detector of detectors) {
+    m.detectorTriggeredTotal.inc({ detector: String(detector) });
+  }
+};
+const recordBlockedRequest = (reason) => {
+  if (!metricsEnabled()) return;
+  getMetrics().blockedRequestsTotal.inc({ reason });
+};
+const recordDomainValidation = (result) => {
+  if (!metricsEnabled()) return;
+  getMetrics().domainValidationTotal.inc({ result });
+};
+const recordSpamEmail = (result) => {
+  if (!metricsEnabled()) return;
+  getMetrics().spamEmailTotal.inc({ result });
+};
+const setMaintenanceModeGauge = (on) => {
+  if (!metricsEnabled()) return;
+  getMetrics().maintenanceMode.set(on ? 1 : 0);
+};
+const metricsMiddleware = () => {
+  return (req, res, next) => {
+    if (!metricsEnabled()) return next();
+    const start = process.hrtime.bigint();
+    res.on("finish", () => {
+      const route = normaliseRoute(req);
+      const labels = {
+        route,
+        method: req.method,
+        status: String(res.statusCode)
+      };
+      const durationSeconds = Number(process.hrtime.bigint() - start) / 1e9;
+      const m = getMetrics();
+      m.httpRequestsTotal.inc(labels);
+      m.httpRequestDuration.observe(labels, durationSeconds);
+    });
+    next();
+  };
+};
+const metricsHandler = (env) => {
+  return async (req, res) => {
+    const token = process.env.PROSOPO_METRICS_TOKEN;
+    if (token && req.headers.authorization !== `Bearer ${token}`) {
+      res.status(401).send("Unauthorized");
+      return;
+    }
+    const m = getMetrics();
+    try {
+      const db = env.getDb();
+      m.redisReady.set(
+        { actor: "general" },
+        db.getRedisConnection().isReady() ? 1 : 0
+      );
+      m.redisReady.set(
+        { actor: "uap" },
+        db.getRedisAccessRulesConnection().isReady() ? 1 : 0
+      );
+    } catch {
+      m.redisReady.set({ actor: "general" }, 0);
+      m.redisReady.set({ actor: "uap" }, 0);
+    }
+    res.set("Content-Type", m.registry.contentType);
+    res.end(await m.registry.metrics());
+  };
+};
+exports.getMetrics = getMetrics;
+exports.metricsEnabled = metricsEnabled;
+exports.metricsHandler = metricsHandler;
+exports.metricsMiddleware = metricsMiddleware;
+exports.recordBlockedRequest = recordBlockedRequest;
+exports.recordBotScore = recordBotScore;
+exports.recordCaptchaIssueError = recordCaptchaIssueError;
+exports.recordCaptchaIssued = recordCaptchaIssued;
+exports.recordCaptchaVerify = recordCaptchaVerify;
+exports.recordDetectorTriggered = recordDetectorTriggered;
+exports.recordDomainValidation = recordDomainValidation;
+exports.recordFrictionlessDecision = recordFrictionlessDecision;
+exports.recordSpamEmail = recordSpamEmail;
+exports.setMaintenanceModeGauge = setMaintenanceModeGauge;

package/dist/cjs/api/public.cjs

@@ -5,12 +5,16 @@ const common = require("@prosopo/common");
 const types = require("@prosopo/types");
 const util = require("@prosopo/util");
 const express = require("express");
+const metrics = require("./metrics.cjs");
 function publicRouter(env) {
   const router = express.Router();
   router.get(types.PublicApiPaths.Healthz, (req, res) => {
     const host = env.config.host && env.config.host.length > 0 ? env.config.host : req.hostname;
     return res.status(200).json({ ok: true, host });
   });
+  if (metrics.metricsEnabled()) {
+    router.get(types.PublicApiPaths.Metrics, metrics.metricsHandler(env));
+  }
   router.get(types.PublicApiPaths.GetProviderDetails, async (req, res, next) => {
     try {
       const db = env.getDb();

package/dist/cjs/api/startProviderApi.cjs

@@ -20,6 +20,7 @@ const headerCheckMiddleware = require("./headerCheckMiddleware.cjs");
 const ignoreMiddleware = require("./ignoreMiddleware.cjs");
 const ipInfoMiddleware = require("./ipInfoMiddleware.cjs");
 const ja4Middleware = require("./ja4Middleware.cjs");
+const metrics = require("./metrics.cjs");
 const _public = require("./public.cjs");
 const robotsMiddleware = require("./robotsMiddleware.cjs");
 const verify = require("./verify.cjs");
@@ -102,8 +103,9 @@ async function startProviderApi(env, admin = false, port) {
       maxAge: 86400
     })
   );
-  apiApp.use(express.json({ limit: "50mb" }));
+  apiApp.use(express.json({ limit: "1mb" }));
   apiApp.use(_public.publicRouter(env));
+  apiApp.use(metrics.metricsMiddleware());
   const isTestOrDevelopmentEnv = process.env.NODE_ENV === "test" || env.config.defaultEnvironment === "development";
   if (!isTestOrDevelopmentEnv) {
     const configRateLimits = env.config.rateLimits;

package/dist/cjs/api/verify.cjs

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const api = require("@prosopo/api");
 const apiExpressRouter = require("@prosopo/api-express-router");
 const common = require("@prosopo/common");
 const types = require("@prosopo/types");
@@ -7,7 +8,26 @@ const utilCrypto = require("@prosopo/util-crypto");
 const express = require("express");
 const tasks = require("../tasks/tasks.cjs");
 const apiToggleMaintenanceModeEndpoint = require("./admin/apiToggleMaintenanceModeEndpoint.cjs");
+const forwardVerify = require("./forwardVerify.cjs");
+const metrics = require("./metrics.cjs");
 const testSiteKey = require("./testSiteKey.cjs");
+const deriveVerifySource = (body) => {
+  if (apiToggleMaintenanceModeEndpoint.getMaintenanceMode()) return "maintenance";
+  try {
+    const token = body?.token;
+    if (token) {
+      const { dapp } = types.decodeProcaptchaOutput(token);
+      if (testSiteKey.isReservedTestSiteKey(dapp)) return "test_key";
+    }
+  } catch {
+  }
+  return "real";
+};
+const VERIFY_PATH_TYPE = {
+  [types.ClientApiPaths.VerifyImageCaptchaSolutionDapp]: types.CaptchaType.image,
+  [types.ClientApiPaths.VerifyPowCaptchaSolution]: types.CaptchaType.pow,
+  [types.ClientApiPaths.VerifyPuzzleCaptchaSolution]: types.CaptchaType.puzzle
+};
 function prosopoVerifyRouter(env) {
   const router = express.Router();
   let userAccessRulesStorage;
@@ -20,6 +40,24 @@ function prosopoVerifyRouter(env) {
     }));
     userAccessRulesStorage = void 0;
   }
+  router.use((req, res, next) => {
+    if (!metrics.metricsEnabled()) return next();
+    const type = VERIFY_PATH_TYPE[req.path];
+    if (!type) return next();
+    const originalJson = res.json.bind(res);
+    res.json = (body) => {
+      if (res.statusCode < 300) {
+        const verified = !!(body && typeof body === "object" && body.verified);
+        metrics.recordCaptchaVerify({
+          type,
+          verified,
+          source: deriveVerifySource(req.body)
+        });
+      }
+      return originalJson(body);
+    };
+    next();
+  });
   router.post(
     types.ClientApiPaths.VerifyImageCaptchaSolutionDapp,
     async (req, res, next) => {
@@ -33,7 +71,6 @@ function prosopoVerifyRouter(env) {
         };
         return res.json(verificationResponse);
       }
-      const tasks$1 = new tasks.Tasks(env, req.logger);
       let parsed;
       try {
         parsed = types.VerifySolutionBody.parse(req.body);
@@ -48,7 +85,7 @@ function prosopoVerifyRouter(env) {
       }
       const { dappSignature, token, ip, maxVerifiedTime, email } = parsed;
       try {
-        const { user, dapp, timestamp, commitmentId } = types.decodeProcaptchaOutput(token);
+        const { user, dapp, timestamp, commitmentId, providerUrl } = types.decodeProcaptchaOutput(token);
         const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
         if (testVerdict !== null) {
           const verificationResponse2 = {
@@ -57,6 +94,20 @@ function prosopoVerifyRouter(env) {
           };
           return res.json(verificationResponse2);
         }
+        const forwarded = await forwardVerify.forwardVerifyIfNotIssuer({
+          env,
+          logger: req.logger,
+          path: types.ClientApiPaths.VerifyImageCaptchaSolutionDapp,
+          providerUrl,
+          dapp,
+          user,
+          body: parsed,
+          alreadyForwarded: req.headers[api.VERIFY_FORWARDED_HEADER] !== void 0
+        });
+        if (forwarded) {
+          return res.json(forwarded);
+        }
+        const tasks$1 = new tasks.Tasks(env, req.logger);
         utilCrypto.validateAddress(dapp, false, 42);
         utilCrypto.validateAddress(user, false, 42);
         const clientRecord = await tasks$1.db.getClientRecord(dapp);
@@ -122,7 +173,6 @@ function prosopoVerifyRouter(env) {
         };
         return res.json(verificationResponse);
       }
-      const tasks$1 = new tasks.Tasks(env, req.logger);
       let parsed;
       try {
         parsed = types.ServerPowCaptchaVerifyRequestBody.parse(req.body);
@@ -137,7 +187,7 @@ function prosopoVerifyRouter(env) {
       }
       try {
         const { token, dappSignature, ip, email } = parsed;
-        const { dapp, user, timestamp, challenge } = types.decodeProcaptchaOutput(token);
+        const { dapp, user, timestamp, challenge, providerUrl } = types.decodeProcaptchaOutput(token);
         const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
         if (testVerdict !== null) {
           const verificationResponse2 = {
@@ -146,6 +196,20 @@ function prosopoVerifyRouter(env) {
           };
           return res.json(verificationResponse2);
         }
+        const forwarded = await forwardVerify.forwardVerifyIfNotIssuer({
+          env,
+          logger: req.logger,
+          path: types.ClientApiPaths.VerifyPowCaptchaSolution,
+          providerUrl,
+          dapp,
+          user,
+          body: parsed,
+          alreadyForwarded: req.headers[api.VERIFY_FORWARDED_HEADER] !== void 0
+        });
+        if (forwarded) {
+          return res.json(forwarded);
+        }
+        const tasks$1 = new tasks.Tasks(env, req.logger);
         utilCrypto.validateAddress(dapp, false, 42);
         utilCrypto.validateAddress(user, false, 42);
         const clientRecord = await tasks$1.db.getClientRecord(dapp);
@@ -217,7 +281,6 @@ function prosopoVerifyRouter(env) {
         };
         return res.json(verificationResponse);
       }
-      const tasks$1 = new tasks.Tasks(env, req.logger);
       let parsed;
       try {
         parsed = types.ServerPuzzleCaptchaVerifyRequestBody.parse(req.body);
@@ -232,7 +295,7 @@ function prosopoVerifyRouter(env) {
       }
       try {
         const { token, dappSignature, ip, email } = parsed;
-        const { dapp, user, timestamp, challenge } = types.decodeProcaptchaOutput(token);
+        const { dapp, user, timestamp, challenge, providerUrl } = types.decodeProcaptchaOutput(token);
         const testVerdict = testSiteKey.resolveTestSiteKeyVerdict(dapp, req.logger);
         if (testVerdict !== null) {
           const verificationResponse2 = {
@@ -241,6 +304,20 @@ function prosopoVerifyRouter(env) {
           };
           return res.json(verificationResponse2);
         }
+        const forwarded = await forwardVerify.forwardVerifyIfNotIssuer({
+          env,
+          logger: req.logger,
+          path: types.ClientApiPaths.VerifyPuzzleCaptchaSolution,
+          providerUrl,
+          dapp,
+          user,
+          body: parsed,
+          alreadyForwarded: req.headers[api.VERIFY_FORWARDED_HEADER] !== void 0
+        });
+        if (forwarded) {
+          return res.json(forwarded);
+        }
+        const tasks$1 = new tasks.Tasks(env, req.logger);
         utilCrypto.validateAddress(dapp, false, 42);
         utilCrypto.validateAddress(user, false, 42);
         const clientRecord = await tasks$1.db.getClientRecord(dapp);

package/dist/cjs/index.cjs

@@ -34,6 +34,7 @@ exports.getIPAddressFromBigInt = util.getIPAddressFromBigInt;
 exports.shuffleArray = util.shuffleArray;
 exports.validateIpAddress = util.validateIpAddress;
 exports.blockMiddleware = block.blockMiddleware;
+exports.asyncHandler = captcha.asyncHandler;
 exports.prosopoRouter = captcha.prosopoRouter;
 exports.prosopoVerifyRouter = verify.prosopoVerifyRouter;
 exports.DEFAULT_JA4 = ja4Middleware.DEFAULT_JA4;

package/dist/cjs/tasks/captchaManager.cjs

@@ -8,7 +8,6 @@ const compositeIpAddress = require("../compositeIpAddress.cjs");
 const enrichDnsEvent = require("./dnsEvent/enrichDnsEvent.cjs");
 const checkSpamEmail = require("./spam/checkSpamEmail.cjs");
 const checkTrafficFilter = require("./spam/checkTrafficFilter.cjs");
-var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 const findHardBlockPolicy = (accessPolicies) => {
   return accessPolicies.find(
     (policy) => policy.type === userAccessPolicy.AccessPolicyType.Block && (policy.deferToVerify || !policy.captchaType)
@@ -19,7 +18,7 @@ class CaptchaManager {
     this.pair = pair;
     this.db = db;
     this.config = config;
-    this.logger = logger$1 || logger.getLogger("info", typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("tasks/captchaManager.cjs", document.baseURI).href);
+    this.logger = logger$1 || logger.getLogger("info", "provider:captcha-manager");
     this.writeQueue = writeQueue ?? null;
   }
   /**
@@ -149,7 +148,27 @@ class CaptchaManager {
         this.writeQueue?.invalidateCachedSession(sessionId),
         cachedHash ? this.writeQueue?.invalidateCachedSessionByHash(cachedHash) : Promise.resolve()
       ]);
-      const sessionRecord = await this.db.checkAndRemoveSession(sessionId);
+      let sessionRecord = await this.db.checkAndRemoveSession(sessionId);
+      let resolvedSessionId = sessionId;
+      if (!sessionRecord && this.writeQueue) {
+        const escalationSessionId = await this.writeQueue.getCachedSessionEscalation(sessionId);
+        if (escalationSessionId && escalationSessionId !== sessionId) {
+          this.logger.info(() => ({
+            msg: "Resolving origin sessionId to escalation",
+            data: {
+              account: clientSettings.account,
+              originSessionId: sessionId,
+              escalationSessionId
+            }
+          }));
+          const escalationRecord = await this.db.checkAndRemoveSession(escalationSessionId);
+          if (escalationRecord) {
+            sessionRecord = escalationRecord;
+            resolvedSessionId = escalationSessionId;
+          }
+          await this.writeQueue.invalidateCachedSessionEscalation(sessionId);
+        }
+      }
       if (!sessionRecord) {
         this.logger.warn(() => ({
           msg: "No session found",
@@ -171,6 +190,7 @@ class CaptchaManager {
           type: requestedCaptchaType
         };
       }
+      sessionId = resolvedSessionId;
       if (this.writeQueue) {
         await Promise.all([
           this.writeQueue.invalidateCachedSession(sessionId),

package/dist/cjs/tasks/imgCaptcha/imgCaptchaTasks.cjs

@@ -456,9 +456,10 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
     return void 0;
   }
   async verifyImageCaptchaSolution(user, dapp, commitmentId, env, maxVerifiedTime, ip, disallowWebView, contextAwareEnabled = false, userAccessRulesStorage, email, spamEmailDomainCheckingEnabled = false, spamFilter, trafficFilter, storeMetadata = false) {
+    const logger = this.logger.with({ commitmentId, dapp });
     const solution = await (commitmentId ? this.getDappUserCommitmentById(commitmentId) : this.getDappUserCommitmentByAccount(user, dapp));
     if (!solution) {
-      this.logger.debug(() => ({
+      logger.debug(() => ({
         msg: "Not verified - no solution found"
       }));
       return {
@@ -484,7 +485,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
     const submittedAt = solution.submittedAtTimestamp;
     const timeSinceCompletion = submittedAt instanceof Date ? currentTime - submittedAt.getTime() : Number.POSITIVE_INFINITY;
     if (timeSinceCompletion > maxVerifiedTime) {
-      this.logger.debug(() => ({
+      logger.debug(() => ({
         msg: "Not verified - timed out"
       }));
       return {
@@ -506,7 +507,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
           solution.ipInfo?.isValid ? solution.ipInfo.asnNumber : void 0
         );
         if (blockPolicy) {
-          this.logger.info(() => ({
+          logger.info(() => ({
             msg: "User blocked by access policy in server image verification",
             data: {
               userAccount: solution.userAccount,
@@ -521,8 +522,8 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
           failStatus = types.ResultReason.ACCESS_POLICY_BLOCK;
         }
       } catch (error) {
-        this.logger.warn(() => ({
-          msg: "Failed to check user access policies in server Image verification",
+        logger.warn(() => ({
+          msg: "Failed to check user access policies in server image verification",
           error
         }));
       }
@@ -532,9 +533,9 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
         const isSpam = await this.checkSpamEmail(email);
         if (isSpam) {
           const emailDomain = email.split("@")[1] || "unknown";
-          this.logger.info(() => ({
+          logger.info(() => ({
             msg: "Spam email domain detected in server image verification",
-            data: { commitmentId, dapp, emailDomain }
+            data: { emailDomain }
           }));
           commitmentUpdates.result = {
             status: types.CaptchaStatus.disapproved,
@@ -543,7 +544,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
           failStatus = types.ResultReason.SPAM_EMAIL_DOMAIN;
         }
       } catch (error) {
-        this.logger.warn(() => ({
+        logger.warn(() => ({
           msg: "Failed to check spam email domain in server image verification",
           error
         }));
@@ -552,9 +553,9 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
     if (!failStatus && spamFilter?.enabled && spamFilter.emailRules?.enabled && email) {
       const result = evaluateEmailSpamRules.evaluateEmailSpamRules(email, spamFilter.emailRules);
       if (result.isSpam) {
-        this.logger.info(() => ({
+        logger.info(() => ({
           msg: "Spam filter rejected email in image verification",
-          data: { commitmentId, dapp, reason: result.reason }
+          data: { reason: result.reason }
         }));
         commitmentUpdates.result = {
           status: types.CaptchaStatus.disapproved,
@@ -578,11 +579,9 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
         enrichedDnsEvent
       );
       if (check.isBlocked) {
-        this.logger.info(() => ({
+        logger.info(() => ({
           msg: "Traffic filter rejected request",
           data: {
-            commitmentId,
-            dapp,
             ip,
             reason: check.reason,
             dnsPeerIp: enrichedDnsEvent?.peerIp,
@@ -611,13 +610,13 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
         const ipValidation = await util.deepValidateIpAddress(
           ip,
           solutionIpAddress,
-          this.logger,
+          logger,
           env.ipInfoService,
           ipValidationRules,
           enrichedDnsEvent?.peerIp
         );
         if (!ipValidation.isValid) {
-          this.logger.error(() => ({
+          logger.error(() => ({
             msg: "IP validation failed for image captcha",
             data: {
               ip,
@@ -658,7 +657,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
         };
       }
       score = frictionlessTasksUtils.computeFrictionlessScore(sessionRecord?.scoreComponents);
-      this.logger.info(() => ({
+      logger.info(() => ({
         data: {
           scoreComponents: sessionRecord?.scoreComponents,
           score,
@@ -667,7 +666,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
         }
       }));
       if (!failStatus && disallowWebView === true && (sessionRecord.webView === true || (sessionRecord.scoreComponents.webView || 0) > 0)) {
-        this.logger.info(() => ({
+        logger.info(() => ({
           msg: "Disallowing webview access - user not verified"
         }));
         commitmentUpdates.result = {
@@ -679,7 +678,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
         failureStatus = types.ResultReason.DISALLOWED_WEBVIEW;
       }
       if (contextAwareEnabled && sessionRecord.reason === types.FrictionlessReason.CONTEXT_AWARE_VALIDATION_FAILED) {
-        this.logger.info(() => ({
+        logger.info(() => ({
           msg: "Context aware validation failed"
         }));
       }
@@ -708,14 +707,13 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
       try {
         const decision = await this.decisionMachineRunner.decide(
           decisionInput,
-          this.logger
+          logger
         );
         if (decision.decision === types.DecisionMachineDecision.Deny) {
           const dmReason = decision.reason || types.ResultReason.CAPTCHA_DECISION_MACHINE_DENIED;
-          this.logger?.info(() => ({
+          logger.info(() => ({
             msg: "Decision machine denied user verification",
             data: {
-              commitmentId,
               reason: decision.reason
             }
           }));
@@ -727,7 +725,7 @@ class ImgCaptchaManager extends captchaManager.CaptchaManager {
           failureStatus = dmReason;
         }
       } catch (error) {
-        this.logger?.error(() => ({
+        logger.error(() => ({
           msg: "Failed to process decision machine",
           err: error
         }));