perimeterx-js-core 0.15.2 → 0.16.0

package/lib/esm/config/remote_config/DefaultRemoteConfigUpdater.js

@@ -1,6 +1,5 @@
-import { HttpMethod } from '../../http';
-import { DefaultTimestampHmacHeaderValidator, PUSH_DATA_FEATURE_HEADER_NAME, PUSH_DATA_HMAC_HEADER_NAME, sleep, } from '../../utils';
-import { REMOTE_CONFIG_PUSH_DATA_FEATURE_NAME, WRITE_REMOTE_CONFIG_ERROR_NAME } from './constants';
+import { DefaultTimestampHmacHeaderValidator, PUSH_DATA_HMAC_HEADER_NAME, sleep, } from '../../utils';
+import { WRITE_REMOTE_CONFIG_ERROR_NAME } from './constants';
 export class DefaultRemoteConfigUpdater {
     config;
     serviceClient;
@@ -14,61 +13,60 @@ export class DefaultRemoteConfigUpdater {
             options.timestampHmacHeaderValidator ||
                 new DefaultTimestampHmacHeaderValidator(config, config.remoteConfigSecret, options.base64Utils, options.hmacUtils);
     }
-    isUpdateRemoteConfigRequest({ requestData: { request } }) {
-        const isCorrectMethod = request.method === HttpMethod.PATCH;
-        const isCorrectFeature = request.headers.get(PUSH_DATA_FEATURE_HEADER_NAME) === REMOTE_CONFIG_PUSH_DATA_FEATURE_NAME;
-        const isHmacHeaderPresent = !!request.headers.get(PUSH_DATA_HMAC_HEADER_NAME);
-        return isCorrectMethod && isCorrectFeature && isHmacHeaderPresent;
+    isUpdateRemoteConfigRequest(context) {
+        return context.isRemoteConfigUpdateRequest;
     }
-    async updateRemoteConfig({ requestData: { request } }) {
-        this.config.logger.debug('identified an update remote config request');
-        if (!(await this.isUpdateRequestValid(request))) {
+    async updateRemoteConfig(context) {
+        context.logger.debug('identified an update remote config request');
+        const { requestData: { request }, } = context;
+        if (!(await this.isUpdateRequestValid(request, context))) {
             return false;
         }
-        const updateRequestData = await this.getUpdateRequestData(request);
+        const updateRequestData = await this.getUpdateRequestData(request, context);
         if (!updateRequestData) {
             return false;
         }
-        const remoteConfig = await this.fetchRemoteConfig(updateRequestData);
+        const remoteConfig = await this.fetchRemoteConfig(updateRequestData, context);
         if (!remoteConfig) {
             return false;
         }
         await this.storageClient.save(remoteConfig);
-        this.config.logger.debug(`successfully updated with remote config version ${remoteConfig.version}`);
+        context.logger.debug(`successfully updated with remote config version ${remoteConfig.version}`);
         return true;
     }
-    async isUpdateRequestValid(request) {
+    async isUpdateRequestValid(request, context) {
         const timestampHmacHeader = request.headers.get(PUSH_DATA_HMAC_HEADER_NAME);
-        const isValid = await this.timestampHmacHeaderValidator.isValid(timestampHmacHeader);
+        const isValid = await this.timestampHmacHeaderValidator.isValid(timestampHmacHeader, context.logger);
         if (!isValid) {
-            this.config.logger.error(`invalid timestamp hmac header received: ${timestampHmacHeader}`, {
+            context.logger.error(`invalid timestamp hmac header received: ${timestampHmacHeader}`, {
                 errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
             });
         }
         return isValid;
     }
-    async getUpdateRequestData(request) {
+    async getUpdateRequestData(request, context) {
         let updateRequestData;
         try {
             updateRequestData = await request.json();
         }
         catch (err) {
-            this.config.logger.error(`could not parse update request body: ${err}`, {
+            context.logger.error(`could not parse update request body: ${err}`, {
                 errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
             });
             return null;
         }
         if (!updateRequestData?.version) {
-            this.config.logger.error(`no version on update request body: ${updateRequestData}`, {
+            context.logger.error(`no version on update request body: ${updateRequestData}`, {
                 errorType: WRITE_REMOTE_CONFIG_ERROR_NAME,
             });
             return null;
         }
         return updateRequestData;
     }
-    async fetchRemoteConfig(updateRequestData) {
+    async fetchRemoteConfig(updateRequestData, context) {
         const { remoteConfigMaxFetchAttempts, remoteConfigRetryIntervalMs, remoteConfigVersion } = this.config;
-        let remoteConfigData, errorText;
+        let errorText;
+        let remoteConfigData;
         for (let i = 0; i < remoteConfigMaxFetchAttempts; i++) {
             try {
                 remoteConfigData = await this.serviceClient.fetch(updateRequestData);
@@ -86,7 +84,7 @@ export class DefaultRemoteConfigUpdater {
         errorText =
             errorText ??
                 `no config version ${updateRequestData.version} found after ${remoteConfigMaxFetchAttempts} attempts, current: ${remoteConfigVersion}, received: ${remoteConfigData?.version}`;
-        this.config.logger.error(errorText, { errorType: WRITE_REMOTE_CONFIG_ERROR_NAME });
+        context.logger.error(errorText, { errorType: WRITE_REMOTE_CONFIG_ERROR_NAME });
     }
     isDesiredRemoteConfigVersion({ version }, remoteConfigData) {
         return version === remoteConfigData.version;

package/lib/esm/config/remote_config/RemoteConfigUtils.js

@@ -0,0 +1,9 @@
+import { HttpMethod } from '../../http';
+import { PUSH_DATA_FEATURE_HEADER_NAME, PUSH_DATA_HMAC_HEADER_NAME } from '../../utils';
+import { REMOTE_CONFIG_PUSH_DATA_FEATURE_NAME } from './constants';
+export var RemoteConfigUtils;
+(function (RemoteConfigUtils) {
+    RemoteConfigUtils.isRemoteConfigUpdateRequest = (request) => request.method === HttpMethod.PATCH &&
+        request.headers.get(PUSH_DATA_FEATURE_HEADER_NAME) === REMOTE_CONFIG_PUSH_DATA_FEATURE_NAME &&
+        !!request.headers.get(PUSH_DATA_HMAC_HEADER_NAME);
+})(RemoteConfigUtils || (RemoteConfigUtils = {}));

package/lib/esm/config/remote_config/index.js

@@ -4,3 +4,4 @@ export * from './service_client';
 export * from './storage_client';
 export * from './DefaultRemoteConfigUpdater';
 export * from './IRemoteConfigUpdater';
+export * from './RemoteConfigUtils';

package/lib/esm/context/DefaultContext.js

@@ -1,13 +1,16 @@
+import { RemoteConfigUtils } from '../config';
 import { BlockAction } from '../blocker';
 import { PXHDSource } from '../pxhd';
 import { TokenOrigin, TokenParseResult } from '../risk_token';
 import { RiskApiCallResult } from '../risk_api';
 import { COOKIE_HEADER_NAME, toReadonlyHeaders, USER_AGENT_HEADER_NAME, } from '../http';
 import { StringSplitCookieParser, PXHD_COOKIE_NAME, PXVID_COOKIE_NAME, X_PX_AUTHORIZATION_HEADER_NAME, } from '../utils';
-import { X_PX_ENFORCER_LOG_HEADER } from '../logger';
+import { DefaultLogger, X_PX_ENFORCER_LOG_HEADER } from '../logger';
 export class DefaultContext {
     requestId;
     tokenOrigin;
+    isRemoteConfigUpdateRequest;
+    shouldSendLogs;
     requestData;
     tokenData;
     riskApiData;
@@ -21,7 +24,6 @@ export class DefaultContext {
     reasons;
     score;
     blockAction;
-    shouldSendLogs;
     pxhd;
     pxde;
     pxdeVerified;
@@ -30,6 +32,7 @@ export class DefaultContext {
     enforcerStartTime;
     config;
     urlUtils;
+    contextLogger;
     constructor(config, request, options) {
         this.enforcerStartTime = Date.now();
         this.config = config;
@@ -46,25 +49,32 @@ export class DefaultContext {
         this.requestId = options.requestIdGenerator.generateRequestId();
         this.blockAction = BlockAction.CAPTCHA;
         this.pxdeVerified = false;
+        this.isRemoteConfigUpdateRequest = RemoteConfigUtils.isRemoteConfigUpdateRequest(request);
+        this.shouldSendLogs = this.isRemoteConfigUpdateRequest || this.isHeaderBasedLoggerRequest(config, request);
+        this.contextLogger = this.createContextLogger(config, this.shouldSendLogs);
         this.requestData = this.createRequestData(config, request, options.cookieParser);
         this.tokenOrigin = this.getTokenOrigin(request);
         if (!this.isMobile) {
             this.setCookiesOnContext();
         }
-        this.shouldSendLogs = this.isHeaderBasedLoggerEnabled();
+    }
+    get logger() {
+        return this.contextLogger;
     }
     get isMobile() {
         return this.tokenOrigin === TokenOrigin.HEADER;
     }
+    createContextLogger(config, shouldSaveLogs) {
+        return new DefaultLogger(config.loggerSeverity, shouldSaveLogs);
+    }
     createRequestData(config, request, cookieParser = new StringSplitCookieParser()) {
         const rawUrl = request.url;
         const url = this.normalizeUrl(rawUrl);
         const isUrlDifferentFromRawUrl = rawUrl !== url.href;
         const method = request.method;
-        const headers = request.headers;
         const cookies = DefaultContext.getCookies(cookieParser, request.headers.get(COOKIE_HEADER_NAME), request.headers.get(config.customCookieHeader));
         const requestCookieNames = Object.keys(cookies);
-        const readOnlyHeaders = toReadonlyHeaders(headers);
+        const readOnlyHeaders = toReadonlyHeaders(request.headers);
         const userAgent = this.extractUserAgentFromHeader(config, readOnlyHeaders);
         const ip = this.extractIpFromHeader(config, readOnlyHeaders) || request.clientIP;
         const httpVersion = request.httpVersion;
@@ -96,7 +106,7 @@ export class DefaultContext {
                 url = this.urlUtils.createUrl(`${url.origin}${this.urlUtils.decodeUriComponent(url.pathname)}${url.search}`);
             }
             catch (e) {
-                this.config.logger.debug(`unable to URL decode reserved characters: ${e}`);
+                this.logger.debug(`unable to URL decode reserved characters: ${e}`);
             }
         }
         url.pathname = url.pathname.replace(/\/+$/, '').replace(/\/+/g, '/');
@@ -133,7 +143,7 @@ export class DefaultContext {
             };
         }
     }
-    isHeaderBasedLoggerEnabled() {
-        return this.config.loggerAuthToken === this.requestData.headers[X_PX_ENFORCER_LOG_HEADER]?.[0];
+    isHeaderBasedLoggerRequest(config, request) {
+        return config.loggerAuthToken && config.loggerAuthToken === request.headers.get(X_PX_ENFORCER_LOG_HEADER);
     }
 }

package/lib/esm/custom_parameters/CustomParametersUtils.js

@@ -8,7 +8,7 @@ export var CustomParametersUtils;
                 return CustomParametersUtils.normalizeCustomParams(parameters);
             }
             catch (e) {
-                config.logger.error(`unable to enrich custom params: ${e}`);
+                context.logger.error(`unable to enrich custom params: ${e}`);
             }
         }
         return null;

package/lib/esm/enforcer/EnforcerBase.js

@@ -31,6 +31,9 @@ export class EnforcerBase {
         this.enforceFlow = this.createEnforceFlow(config, initializationBlock);
         this.postEnforceFlow = this.createPostEnforceFlow(config, initializationBlock);
         this.endEnforcerFlow = this.createEndEnforcerFlow(config, initializationBlock);
+        if (!this.config.moduleEnabled) {
+            this.config.logger.debug('HUMAN enforcer is disabled, will not enforce');
+        }
     }
     createFilterFlow(config, initializationBlock) {
         return new FilterFlow(config, initializationBlock);
@@ -50,26 +53,27 @@ export class EnforcerBase {
      * @returns Promise<Res|null> - A Promise resolving to a Res or null depending on the action that should be taken.
      */
     async enforce(...args) {
+        let context;
         try {
             if (!this.config.moduleEnabled) {
-                this.config.logger.debug('module is disabled, will not enforce');
                 return null;
             }
-            return await this.doEnforce(...args);
+            context = await this.constructContext(...args);
+            return await this.doEnforce(context, ...args);
         }
         catch (e) {
-            this.config.logger.error(`caught error in enforce - ${e}`);
+            (context || this.config).logger.error(`caught error in enforce - ${e}`);
             return null;
         }
     }
     /**
      * Performs all enforcer functionality on the incoming request context.
+     * @param context
      * @param args - The EnforceArgs required to enforce the incoming request.
      * @returns Promise<Res|null> -  A Promise resolving to a Res or null depending on the action that should be taken.
      * @protected
      */
-    async doEnforce(...args) {
-        const context = await this.constructContext(...args);
+    async doEnforce(context, ...args) {
         let result = await this.filterFlow.execute(context);
         if (result.done) {
             await this.endEnforcerFlow.execute(context);
@@ -90,8 +94,12 @@ export class EnforcerBase {
      * @protected
      */
     async postEnforce(...args) {
+        let context;
         try {
-            const context = this.retrieveContext(...args);
+            if (!this.config.moduleEnabled) {
+                return;
+            }
+            context = this.retrieveContext(...args);
             if (context) {
                 context.response = await this.convertToOutgoingResponse(...args);
                 await this.postEnforceFlow.execute(context);
@@ -99,10 +107,13 @@ export class EnforcerBase {
             }
         }
         catch (e) {
-            this.config.logger.error(`caught error in post enforce - ${e}`);
+            (context || this.config).logger.error(`caught error in post enforce - ${e}`);
         }
     }
     async sendAdditionalS2SActivity(...args) {
+        if (!this.config.moduleEnabled) {
+            return;
+        }
         const context = this.retrieveContext(...args);
         if (context) {
             await this.activityClient.sendActivities(context);

package/lib/esm/graphql/DefaultGraphQLParser.js

@@ -2,12 +2,10 @@ import { isRouteInPatterns } from '../utils';
 import { HttpMethod } from '../http';
 import { GraphQLOperationType } from './model';
 export class DefaultGraphQLParser {
-    config;
     graphqlRoutes;
     sensitiveOperationTypes;
     sensitiveOperationNames;
     constructor(config) {
-        this.config = config;
         this.graphqlRoutes = config.graphqlRoutes;
         this.sensitiveOperationNames = config.sensitiveGraphqlOperationNames;
         this.sensitiveOperationTypes = config.sensitiveGraphqlOperationTypes;
@@ -15,27 +13,28 @@ export class DefaultGraphQLParser {
     isGraphQLRequest({ requestData }) {
         return (requestData.method === HttpMethod.POST && isRouteInPatterns(requestData.url.pathname, this.graphqlRoutes));
     }
-    async parseGraphQLRequest({ requestData }) {
+    async parseGraphQLRequest(context) {
         try {
-            const graphQLOperations = await this.getGraphQLOperationsFromBody(requestData);
+            const { requestData } = context;
+            const graphQLOperations = await this.getGraphQLOperationsFromBody(requestData.request, context);
             if (!graphQLOperations) {
-                this.config.logger.debug('unable to get graphql operations from request body');
+                context.logger.debug('unable to get graphql operations from request body');
                 return null;
             }
             const data = this.parseGraphQLOperations(graphQLOperations);
             if (!data || data.length === 0) {
-                this.config.logger.debug('unable to parse graphql operations');
+                context.logger.debug('unable to parse graphql operations');
                 return null;
             }
-            this.config.logger.debug(`${data.length} graphql operation${data.length === 1 ? '' : 's'} parsed successfully`);
+            context.logger.debug(`${data.length} graphql operation${data.length === 1 ? '' : 's'} parsed successfully`);
             return data;
         }
         catch (e) {
-            this.config.logger.debug(`unable to parse graphql request: ${e}`);
+            context.logger.debug(`unable to parse graphql request: ${e}`);
             return null;
         }
     }
-    async getGraphQLOperationsFromBody({ request, }) {
+    async getGraphQLOperationsFromBody(request, context) {
         try {
             let body = await request.json();
             if (!body) {
@@ -44,7 +43,7 @@ export class DefaultGraphQLParser {
             return Array.isArray(body) ? body : [body];
         }
         catch (e) {
-            this.config.logger.debug(`unable to parse body to json: ${e}`);
+            context.logger.debug(`unable to parse body to json: ${e}`);
             return null;
         }
     }

package/lib/esm/impl/url/DefaultUrlUtils.js

@@ -1,6 +1,12 @@
+import { UrlImpl } from './UrlImpl';
 export class DefaultUrlUtils {
     createUrl(rawUrl) {
-        return new URL(rawUrl);
+        try {
+            return new URL(rawUrl);
+        }
+        catch (e) {
+            return new UrlImpl(rawUrl);
+        }
     }
     createUrlSearchParams(params) {
         return new URLSearchParams(params);

package/lib/esm/logger/DefaultLogger.js

@@ -1,7 +1,7 @@
 import { LoggerBase } from './LoggerBase';
 export class DefaultLogger extends LoggerBase {
-    constructor(loggerSeverity) {
-        super(loggerSeverity);
+    constructor(loggerSeverity, shouldSaveLogs) {
+        super(loggerSeverity, shouldSaveLogs);
     }
     log(message) {
         /* eslint-disable no-console */

package/lib/esm/logger/HttpLogServiceClient.js

@@ -2,54 +2,52 @@ import { EXTERNAL_LOGGER_SERVICE_PATH } from './constants';
 import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../http';
 import { getAuthorizationHeader } from '../utils';
 export class HttpLogServiceClient {
-    appId;
-    backendUrl;
-    loggerAuthToken;
-    remoteConfigId;
-    remoteConfigVersion;
-    logger;
+    config;
     httpClient;
     constructor(config, httpClient) {
-        this.appId = config.appId;
-        this.backendUrl = config.backendScoreApiUrl;
-        this.loggerAuthToken = config.loggerAuthToken;
-        this.remoteConfigId = config.remoteConfigId;
-        this.remoteConfigVersion = config.remoteConfigVersion;
-        this.logger = config.logger;
+        this.config = config;
         this.httpClient = httpClient;
     }
-    async sendLogs(context, logs) {
+    async sendLogs(context) {
+        const logs = context.logger.getLogs();
         try {
-            const enrichedLogs = logs.map((log) => this.enrichLogRecord(context, log));
+            const logMetadata = this.getLogMetadata(context);
+            const enrichedLogs = logs.map((log) => this.enrichLogRecord(log, logMetadata));
             await this.postLogs(enrichedLogs);
         }
         catch (e) {
-            this.logger.error(`unable to send logs: ${e}`);
+            this.config.logger.error(`logs for ${context.requestId}: ${JSON.stringify(logs)}`);
+            this.config.logger.error(`unable to send logs: ${e}`);
         }
     }
-    enrichLogRecord(context, log) {
-        const { method, url, rawUrl } = context.requestData;
-        const logMeta = {
+    getLogMetadata(context) {
+        const { requestId, requestData: { method, url, rawUrl }, } = context;
+        const { appId, moduleVersion, remoteConfigId, remoteConfigVersion } = this.config;
+        const logMetadata = {
             container: 'enforcer',
-            appID: this.appId,
-            method: method,
+            appID: appId,
+            method,
             host: url.host,
             url: rawUrl,
             path: url.pathname + url.search,
-            requestId: context.requestId,
+            requestId,
+            moduleVersion,
         };
-        if (this.remoteConfigId && this.remoteConfigVersion) {
-            logMeta.remoteConfigID = this.remoteConfigId;
-            logMeta.remoteConfigVersion = this.remoteConfigVersion;
+        if (remoteConfigId && remoteConfigVersion) {
+            logMetadata.remoteConfigID = remoteConfigId;
+            logMetadata.remoteConfigVersion = remoteConfigVersion;
         }
-        return { ...logMeta, ...log };
+        return logMetadata;
+    }
+    enrichLogRecord(log, logMetadata) {
+        return { ...logMetadata, ...log };
     }
     async postLogs(logRecords) {
-        const url = `${this.backendUrl}${EXTERNAL_LOGGER_SERVICE_PATH}`;
+        const url = `${this.config.backendScoreApiUrl}${EXTERNAL_LOGGER_SERVICE_PATH}`;
         const method = HttpMethod.POST;
         const headers = {
             [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
-            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.loggerAuthToken)],
+            [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.loggerAuthToken)],
         };
         const body = JSON.stringify(logRecords);
         const req = new OutgoingRequestImpl({ url, method, headers, body });

package/lib/esm/logger/LoggerBase.js

@@ -1,9 +1,11 @@
 import { LoggerSeverity } from './LoggerSeverity';
 export class LoggerBase {
     loggerSeverity;
+    shouldSaveLogs;
     logs;
-    constructor(loggerSeverity = LoggerSeverity.ERROR, logs = []) {
+    constructor(loggerSeverity = LoggerSeverity.ERROR, shouldSaveLogs, logs = []) {
         this.loggerSeverity = loggerSeverity;
+        this.shouldSaveLogs = shouldSaveLogs;
         this.logs = logs;
     }
     debug(message, metadata) {
@@ -37,6 +39,9 @@ export class LoggerBase {
         return this.logs;
     }
     recordLog(message, loggerSeverity, metadata) {
+        if (!this.shouldSaveLogs) {
+            return;
+        }
         const logRecord = {
             ...metadata,
             message: message,

package/lib/esm/monitored_request/MonitoredRequestUtils.js

@@ -3,9 +3,9 @@ export var MonitoredRequestUtils;
 (function (MonitoredRequestUtils) {
     MonitoredRequestUtils.isMonitoredRequest = async (config, context) => {
         const { url, request } = context.requestData;
-        const isEnforcedRequest = MonitoredRequestUtils.isEnforcedRoute(url, config.enforcedRoutes) || (await MonitoredRequestUtils.invokeCustomIsEnforcedRequest(config, request));
+        const isEnforcedRequest = MonitoredRequestUtils.isEnforcedRoute(url, config.enforcedRoutes) || (await MonitoredRequestUtils.invokeCustomIsEnforcedRequest(config, context));
         const monitoredRoute = !isEnforcedRequest &&
-            (MonitoredRequestUtils.isMonitoredRoute(url, config.monitoredRoutes) || (await MonitoredRequestUtils.invokeCustomIsMonitoredRequest(config, request)));
+            (MonitoredRequestUtils.isMonitoredRoute(url, config.monitoredRoutes) || (await MonitoredRequestUtils.invokeCustomIsMonitoredRequest(config, context)));
         const monitorMode = !isEnforcedRequest && config.moduleMode === ModuleMode.MONITOR;
         return (monitorMode || monitoredRoute) && !MonitoredRequestUtils.isAllowedToBypassMonitor(config.bypassMonitorHeader, request);
     };
@@ -15,24 +15,24 @@ export var MonitoredRequestUtils;
     MonitoredRequestUtils.isEnforcedRoute = (url, enforcedRoutes) => {
         return isRouteInPatterns(url.pathname, enforcedRoutes);
     };
-    MonitoredRequestUtils.invokeCustomIsEnforcedRequest = async (config, request) => {
+    MonitoredRequestUtils.invokeCustomIsEnforcedRequest = async (config, context) => {
         if (config.customIsEnforcedRequest && typeof config.customIsEnforcedRequest === 'function') {
             try {
-                return await config.customIsEnforcedRequest(request.getUnderlyingRequest());
+                return await config.customIsEnforcedRequest(context.requestData.request.getUnderlyingRequest());
             }
             catch (err) {
-                config.logger.debug(`caught custom enforced request error - ${err}`);
+                context.logger.debug(`caught custom enforced request error - ${err}`);
             }
         }
         return false;
     };
-    MonitoredRequestUtils.invokeCustomIsMonitoredRequest = async (config, request) => {
+    MonitoredRequestUtils.invokeCustomIsMonitoredRequest = async (config, context) => {
         if (config.customIsMonitoredRequest && typeof config.customIsMonitoredRequest === 'function') {
             try {
-                return await config.customIsMonitoredRequest(request.getUnderlyingRequest());
+                return await config.customIsMonitoredRequest(context.requestData.request.getUnderlyingRequest());
             }
             catch (err) {
-                config.logger.debug(`caught custom monitored request error - ${err}`);
+                context.logger.debug(`caught custom monitored request error - ${err}`);
             }
         }
         return false;

package/lib/esm/phase/impl/CreateBlockResponsePhase.js

@@ -15,7 +15,7 @@ export class CreateBlockResponsePhase {
         if (context.action !== Action.BLOCK) {
             return { done: false };
         }
-        this.config.logger.debug('create block response phase');
+        context.logger.debug('create block response phase');
         let response = this.createBlockResponse(context);
         if (!response) {
             return { done: false };
@@ -29,7 +29,7 @@ export class CreateBlockResponsePhase {
             if (context.reasons[name]) {
                 const blocker = this.blockers[name];
                 if (blocker?.shouldBlock(context)) {
-                    this.config.logger.debug(`returning ${name} block response`);
+                    context.logger.debug(`returning ${name} block response`);
                     response = blocker.createBlockResponse(context);
                     break;
                 }

package/lib/esm/phase/impl/DecideActionPhase.js

@@ -2,17 +2,13 @@ import { LoggerSeverity } from '../../logger';
 import { Action, getDecisionFromContext } from '../../action';
 import { BlockAction } from '../../blocker';
 export class DecideActionPhase {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
     async updateContextDecision(context) {
         const { action, reasons } = getDecisionFromContext(context);
-        if (this.config.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {
+        if (context.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {
             const productReasons = Object.entries(reasons)
                 .map(([prod, reason]) => `${prod} -> ${reason}`)
                 .join(', ');
-            this.config.logger.debug(`decision: ${action}, reasons: ${productReasons}`);
+            context.logger.debug(`decision: ${action}, reasons: ${productReasons}`);
         }
         context.action = action;
         context.reasons = reasons;

package/lib/esm/phase/impl/EnrichContextFromRequestPhase.js

@@ -1,17 +1,19 @@
 import { CustomParametersUtils } from '../../custom_parameters';
 import { DecideActionPhase } from './DecideActionPhase';
 export class EnrichContextFromRequestPhase extends DecideActionPhase {
+    config;
     products;
     dataEnrichment;
     graphQLParser;
     constructor(config, products, dataEnrichment, graphQLParser) {
-        super(config);
+        super();
+        this.config = config;
         this.products = products;
         this.dataEnrichment = dataEnrichment;
         this.graphQLParser = graphQLParser;
     }
     async execute(context) {
-        this.config.logger.debug('enrich context from request phase');
+        context.logger.debug('enrich context from request phase');
         await this.addPxdeToContext(context);
         await this.addGraphQLDataToContext(context);
         await this.addCustomParametersToContext(context);

package/lib/esm/phase/impl/EnrichContextFromResponsePhase.js

@@ -6,7 +6,7 @@ export class EnrichContextFromResponsePhase {
         this.products = products;
     }
     async execute(context) {
-        this.config.logger.debug('enrich context from response phase');
+        context.logger.debug('enrich context from response phase');
         await this.addProductDataToContext(context);
         return { done: false };
     }

package/lib/esm/phase/impl/FirstPartyPhase.js

@@ -12,15 +12,15 @@ export class FirstPartyPhase {
         for (const firstParty of this.firstParties) {
             const firstPartyData = await firstParty.handleFirstPartyRequest(context);
             if (firstPartyData) {
-                const response = await this.sendFirstPartyRequest(firstPartyData);
+                const response = await this.sendFirstPartyRequest(firstPartyData, context);
                 return { done: true, response };
             }
         }
         return { done: false };
     }
-    async sendFirstPartyRequest({ request, defaultResponse }) {
+    async sendFirstPartyRequest({ request, defaultResponse }, context) {
         if (!request) {
-            this.config.logger.debug('no first party request provided, returning default response');
+            context.logger.debug('no first party request provided, returning default response');
             return defaultResponse;
         }
         try {
@@ -28,7 +28,7 @@ export class FirstPartyPhase {
             return MinimalResponseUtils.from(response);
         }
         catch (e) {
-            this.config.logger.debug(`caught error, returning default first party response: ${e}`);
+            context.logger.debug(`caught error, returning default first party response: ${e}`);
             return defaultResponse;
         }
     }

package/lib/esm/phase/impl/RiskApiPhase.js

@@ -6,7 +6,7 @@ export class RiskApiPhase extends DecideActionPhase {
     products;
     riskApiClient;
     constructor(config, products, riskApiClient) {
-        super(config);
+        super();
         this.products = products;
         this.riskApiClient = riskApiClient;
     }

package/lib/esm/phase/impl/SendLogsPhase.js

@@ -7,9 +7,9 @@ export class SendLogsPhase {
     }
     async execute(context) {
         if (context.shouldSendLogs) {
-            await this.logServiceClient?.sendLogs(context, this.config.logger.getLogs());
+            await this.logServiceClient?.sendLogs(context);
         }
-        this.config.logger.clearLogs();
+        context.logger.clearLogs();
         return { done: false };
     }
 }

package/lib/esm/phase/impl/UpdateRemoteConfigPhase.js

@@ -7,7 +7,6 @@ export class UpdateRemoteConfigPhase {
     }
     async execute(context) {
         if (this.remoteConfigUpdater.isUpdateRemoteConfigRequest(context)) {
-            context.shouldSendLogs = true;
             const isSuccessful = await this.remoteConfigUpdater.updateRemoteConfig(context);
             return { done: true, response: this.getUpdateConfigResponse(isSuccessful) };
         }