perimeterx-js-core 0.15.2 → 0.16.0

package/lib/esm/products/account_defender/AccountDefender.js

@@ -9,7 +9,7 @@ export class AccountDefender {
     }
     async enrichContextFromRequest(context) {
         const crossTabSession = context.requestData.cookies[CROSS_TAB_SESSION_COOKIE_NAME];
-        const jwtData = this.getJwtData(context.requestData);
+        const jwtData = this.getJwtData(context);
         return { crossTabSession, ...jwtData };
     }
     async enrichContextFromRiskApi(context) {
@@ -24,10 +24,11 @@ export class AccountDefender {
     async modifyOutgoingResponse(context) {
         return;
     }
-    getJwtData(requestData) {
+    getJwtData(context) {
         let jwtToken;
         let userIdFieldName;
         let additionalFieldNames;
+        const { requestData } = context;
         if (this.config.jwtCookieName) {
             jwtToken = requestData.cookies[this.config.jwtCookieName];
             if (jwtToken) {
@@ -42,11 +43,11 @@ export class AccountDefender {
                 additionalFieldNames = this.config.jwtHeaderAdditionalFieldNames;
             }
         }
-        return jwtToken ? this.extractJwtData(jwtToken, userIdFieldName, additionalFieldNames) : null;
+        return jwtToken ? this.extractJwtData(jwtToken, userIdFieldName, additionalFieldNames, context) : null;
     }
-    extractJwtData(jwt, userIdFieldName, additionalFieldNames) {
+    extractJwtData(jwt, userIdFieldName, additionalFieldNames, context) {
         try {
-            const decodedJwt = this.getDecodedJwt(jwt);
+            const decodedJwt = this.getDecodedJwt(jwt, context);
             if (decodedJwt) {
                 const appUserId = getPropertyFromObject(decodedJwt, ...userIdFieldName.split('.'));
                 const additionalFields = additionalFieldNames.reduce((matchedFields, fieldName) => {
@@ -61,18 +62,18 @@ export class AccountDefender {
             }
         }
         catch (e) {
-            this.config.logger.debug(`unable to get account defender JWT data: ${e}`);
+            context.logger.debug(`unable to get account defender JWT data: ${e}`);
         }
         return null;
     }
-    getDecodedJwt(jwt) {
+    getDecodedJwt(jwt, context) {
         try {
             const encodedPayload = jwt.split('.')?.[1];
             const base64 = encodedPayload.replace('-', '+').replace('_', '/');
             return JSON.parse(this.base64Utils.base64Decode(base64));
         }
         catch (e) {
-            this.config.logger.debug(`unable to decode account defender jwt token: ${e}`);
+            context.logger.debug(`unable to decode account defender jwt token: ${e}`);
             return null;
         }
     }

package/lib/esm/products/bot_defender/filter/DefaultBotDefenderFilter.js

@@ -9,15 +9,15 @@ export class DefaultBotDefenderFilter {
         this.ipRangeChecker = ipRangeChecker;
     }
     async shouldFilter(context) {
-        const { requestData } = context;
-        const filterReason = await this.getFilterReason(requestData);
+        const filterReason = await this.getFilterReason(context);
         if (filterReason !== FilterReason.NONE) {
-            this.config.logger.debug(`filter request due to ${filterReason}`);
+            context.logger.debug(`filter request due to ${filterReason}`);
             return true;
         }
         return false;
     }
-    async getFilterReason(requestData) {
+    async getFilterReason(context) {
+        const { requestData } = context;
         if (this.shouldFilterByExtension(requestData)) {
             return FilterReason.EXTENSION;
         }
@@ -33,7 +33,7 @@ export class DefaultBotDefenderFilter {
         if (this.shouldFilterByIp(requestData.ip)) {
             return FilterReason.IP;
         }
-        if (await this.shouldFilterByCustomFunction(requestData.request)) {
+        if (await this.shouldFilterByCustomFunction(context)) {
             return FilterReason.CUSTOM;
         }
         return FilterReason.NONE;
@@ -57,13 +57,13 @@ export class DefaultBotDefenderFilter {
     shouldFilterByUserAgent(userAgent) {
         return this.config.filteredUserAgents.includes(userAgent);
     }
-    async shouldFilterByCustomFunction(request) {
+    async shouldFilterByCustomFunction(context) {
         if (this.config.customIsFilteredRequest && typeof this.config.customIsFilteredRequest === 'function') {
             try {
-                return await this.config.customIsFilteredRequest(request.getUnderlyingRequest());
+                return await this.config.customIsFilteredRequest(context.requestData.request.getUnderlyingRequest());
             }
             catch (err) {
-                this.config.logger.debug(`caught custom filtered request error - ${err}`);
+                context.logger.debug(`caught custom filtered request error - ${err}`);
             }
         }
         return false;

package/lib/esm/products/bot_defender/first_party/DefaultBotDefenderFirstParty.js

@@ -30,12 +30,12 @@ export class DefaultBotDefenderFirstParty {
         if (!this.config.firstPartyEnabled) {
             return { defaultResponse };
         }
-        const url = this.getThirdPartySensorScriptUrl();
+        const url = this.getThirdPartySensorScriptUrl(context);
         if (!url) {
             return { defaultResponse };
         }
         const request = await this.getOutgoingRequest(url, context);
-        this.config.logger.debug(`proxying first party sensor script ${context.requestData.url.pathname} to ${url}`);
+        context.logger.debug(`proxying first party sensor script ${context.requestData.url.pathname} to ${url}`);
         return { request, defaultResponse };
     }
     async proxyXhrRequest(context, prefix) {
@@ -48,7 +48,7 @@ export class DefaultBotDefenderFirstParty {
             return { defaultResponse };
         }
         const request = await this.getOutgoingRequest(url, context);
-        this.config.logger.debug(`proxying first party XHR request ${context.requestData.url.pathname} to ${url}`);
+        context.logger.debug(`proxying first party XHR request ${context.requestData.url.pathname} to ${url}`);
         return { request, defaultResponse };
     }
     static getDefaultXhrResponse(path) {
@@ -69,18 +69,19 @@ export class DefaultBotDefenderFirstParty {
             return { defaultResponse };
         }
         const request = await this.getOutgoingRequest(url, context);
-        this.config.logger.debug(`proxying first party captcha script ${context.requestData.url.pathname} to ${url}`);
+        context.logger.debug(`proxying first party captcha script ${context.requestData.url.pathname} to ${url}`);
         return { request, defaultResponse };
     }
-    async getOutgoingRequest(url, { requestData, vid }) {
+    async getOutgoingRequest(url, context) {
         return new OutgoingRequestImpl({
             url: url.href,
-            method: requestData.method,
-            headers: this.prepareFirstPartyHeaders(url, requestData, vid),
-            body: requestData.request.body,
+            method: context.requestData.method,
+            headers: this.prepareFirstPartyHeaders(url, context),
+            body: context.requestData.request.body,
         });
     }
-    prepareFirstPartyHeaders(url, requestData, vid) {
+    prepareFirstPartyHeaders(url, context) {
+        const { requestData, vid } = context;
         let headers = toMutableHeaders(requestData.headers);
         try {
             headers = removeSensitiveHeaders(headers, this.config.sensitiveHeaders);
@@ -93,7 +94,7 @@ export class DefaultBotDefenderFirstParty {
             }
         }
         catch (e) {
-            this.config.logger.error(`Caught error preparing first party headers: ${e}`);
+            context.logger.error(`Caught error preparing first party headers: ${e}`);
         }
         return headers;
     }
@@ -108,12 +109,12 @@ export class DefaultBotDefenderFirstParty {
         headers[FIRST_PARTY_HEADER_NAME] = [FIRST_PARTY_HEADER_VALUE];
         headers[X_PX_ENFORCER_TRUE_IP_HEADER_NAME] = [ip];
     }
-    getThirdPartySensorScriptUrl() {
+    getThirdPartySensorScriptUrl(context) {
         try {
             return this.urlUtils.createUrl(`${this.config.backendClientUrl}/${this.config.appId}/main.min.js`);
         }
         catch (e) {
-            this.config.logger.debug(`unable to create third party sensor URL: ${e}`);
+            context.logger.debug(`unable to create third party sensor URL: ${e}`);
             return null;
         }
     }
@@ -124,7 +125,7 @@ export class DefaultBotDefenderFirstParty {
             return this.urlUtils.createUrl(`${backendCaptchaUrl}/${appId}${FirstPartySuffix.CAPTCHA}.js${originalUrl.search}`);
         }
         catch (e) {
-            this.config.logger.debug(`unable to create third party captcha URL: ${e}`);
+            context.logger.debug(`unable to create third party captcha URL: ${e}`);
             return null;
         }
     }
@@ -135,13 +136,13 @@ export class DefaultBotDefenderFirstParty {
             const thirdPartyUrl = this.urlUtils.createUrl(`${this.config.backendCollectorUrl}${pathname}${originalUrl.search}`);
             const { host } = this.urlUtils.createUrl(this.config.backendCollectorUrl);
             if (!this.isValidThirdPartyUrl(thirdPartyUrl, host, pathname)) {
-                this.config.logger.debug(`invalid third party url: ${thirdPartyUrl}`);
+                context.logger.debug(`invalid third party url: ${thirdPartyUrl}`);
                 return null;
             }
             return thirdPartyUrl;
         }
         catch (e) {
-            this.config.logger.debug(`unable to create third party XHR URL: ${e}`);
+            context.logger.debug(`unable to create third party XHR URL: ${e}`);
             return null;
         }
     }

package/lib/esm/products/credential_intelligence/endpoint/CredentialEndpoint.js

@@ -1,11 +1,9 @@
 export class CredentialEndpoint {
-    config;
     matcher;
     extractor;
     protocol;
     loginSuccessfulParser;
     constructor(config, matcher, extractor, protocol, loginSuccessfulParser) {
-        this.config = config;
         this.matcher = matcher;
         this.extractor = extractor;
         this.protocol = protocol;
@@ -14,27 +12,27 @@ export class CredentialEndpoint {
     matches(requestData) {
         return this.matcher.matches(requestData);
     }
-    async getCredentialData(request) {
+    async getCredentialData(context) {
         try {
-            const credentials = await this.extractor.extractCredentials(request);
+            const credentials = await this.extractor.extractCredentials(context.requestData.request);
             if (!credentials?.user && !credentials?.pass) {
-                this.config.logger.debug('unable to extract credentials');
+                context.logger.debug('unable to extract credentials');
                 return null;
             }
-            this.config.logger.debug(`successfully extracted credentials`);
+            context.logger.debug(`successfully extracted credentials`);
             return await this.protocol.hashCredentials(credentials);
         }
         catch (e) {
-            this.config.logger.debug(`caught error extracting credentials: ${e}`);
+            context.logger.debug(`caught error extracting credentials: ${e}`);
             return null;
         }
     }
-    async isLoginSuccessful(response) {
+    async isLoginSuccessful(context) {
         try {
-            return this.loginSuccessfulParser.isLoginSuccessful(response);
+            return this.loginSuccessfulParser.isLoginSuccessful(context.response);
         }
         catch (e) {
-            this.config.logger.debug(`caught error determining login successful: ${e}`);
+            context.logger.debug(`caught error determining login successful: ${e}`);
             return null;
         }
     }

package/lib/esm/products/credential_intelligence/endpoint/CredentialEndpointManager.js

@@ -7,13 +7,13 @@ export class CredentialEndpointManager {
     getEndpointIndex({ requestData }) {
         return this.endpoints.findIndex((endpoint) => endpoint.matches(requestData));
     }
-    async getCredentialsData(endpointIndex, { requestData }) {
-        return await this.endpoints[endpointIndex]?.getCredentialData(requestData.request);
+    async getCredentialsData(endpointIndex, context) {
+        return await this.endpoints[endpointIndex]?.getCredentialData(context);
     }
-    async isLoginSuccessful(endpointIndex, { response }) {
-        if (!response) {
+    async isLoginSuccessful(endpointIndex, context) {
+        if (!context.response) {
             return undefined;
         }
-        return await this.endpoints[endpointIndex]?.isLoginSuccessful(response);
+        return await this.endpoints[endpointIndex]?.isLoginSuccessful(context);
     }
 }

package/lib/esm/pxde/DefaultDataEnrichment.js

@@ -13,48 +13,48 @@ export class DefaultDataEnrichment {
         try {
             const pxdeCookie = context.requestData.cookies[PXDE_COOKIE_NAME];
             if (pxdeCookie) {
-                return await this.parsePxde(pxdeCookie);
+                return await this.parsePxde(pxdeCookie, context);
             }
         }
         catch (e) {
-            this.config.logger.debug(`unable to parse pxde cookie - ${e}`);
+            context.logger.debug(`unable to parse pxde cookie - ${e}`);
         }
         return null;
     }
-    async parsePxde(pxdeCookie) {
+    async parsePxde(pxdeCookie, context) {
         const pxdeParts = pxdeCookie.split(PXDE_COOKIE_DELIMITER);
         if (pxdeParts.length !== PXDE_COOKIE_PARTS_COUNT) {
-            this.config.logger.debug(`malformed pxde cookie: ${pxdeCookie}`);
+            context.logger.debug(`malformed pxde cookie: ${pxdeCookie}`);
             return null;
         }
         const hmac = pxdeParts[PXDE_HMAC_INDEX];
         const encodedPayload = pxdeParts[PXDE_PAYLOAD_INDEX];
         if (!hmac || !encodedPayload) {
-            this.config.logger.debug(`malformed pxde cookie: hmac: ${hmac}, payload: ${encodedPayload}`);
+            context.logger.debug(`malformed pxde cookie: hmac: ${hmac}, payload: ${encodedPayload}`);
             return null;
         }
         return {
-            pxde: await this.parsePxdePayload(encodedPayload),
-            pxdeVerified: await this.verifyPxdeHmac(hmac, encodedPayload),
+            pxde: await this.parsePxdePayload(encodedPayload, context),
+            pxdeVerified: await this.verifyPxdeHmac(hmac, encodedPayload, context),
         };
     }
-    async verifyPxdeHmac(givenHmac, encodedPayload) {
+    async verifyPxdeHmac(givenHmac, encodedPayload, context) {
         try {
             return (givenHmac ===
                 (await this.hmacUtils.createHmac(Algorithm.SHA256, encodedPayload, this.config.cookieSecret)));
         }
         catch (e) {
-            this.config.logger.debug(`failed verifying pxde hmac: ${e}`);
+            context.logger.debug(`failed verifying pxde hmac: ${e}`);
             return false;
         }
     }
-    async parsePxdePayload(encodedPayload) {
+    async parsePxdePayload(encodedPayload, context) {
         try {
             const decodedPayload = this.base64Utils.base64Decode(encodedPayload);
             return JSON.parse(decodedPayload);
         }
         catch (e) {
-            this.config.logger.debug(`failed parsing pxde payload: ${e}`);
+            context.logger.debug(`failed parsing pxde payload: ${e}`);
             return null;
         }
     }

package/lib/esm/risk_api/client/PostRiskApiClientBase.js

@@ -20,7 +20,7 @@ export class PostRiskApiClientBase {
         const riskApiData = { riskApiCallResult: RiskApiCallResult.NONE };
         try {
             const riskActivity = this.createRiskActivity(context);
-            response = await this.sendRiskActivity(riskActivity, riskApiData);
+            response = await this.sendRiskActivity(riskActivity, riskApiData, context);
             if (response?.status !== 200) {
                 return await this.handleS2SError(riskApiData, response);
             }
@@ -29,14 +29,14 @@ export class PostRiskApiClientBase {
             if (!(await riskResponse.validate())) {
                 return await this.handleS2SError(riskApiData, response);
             }
-            this.config.logger.debug(`received risk response, score: ${riskResponse.score}, rtt: ${riskApiData.riskRtt}`);
+            context.logger.debug(`received risk response, score: ${riskResponse.score}, rtt: ${riskApiData.riskRtt}`);
             return riskApiData;
         }
         catch (err) {
             if (err.name === EnforcerErrorName.ENFORCER_TIMEOUT_ERROR) {
                 return this.handleS2STimeout(riskApiData);
             }
-            this.config.logger.error(`caught error in risk api: ${err} - ${JSON.stringify(context.requestData.url)}`);
+            context.logger.error(`caught error in risk api: ${err} - ${JSON.stringify(context.requestData.url)}`);
             return await this.handleS2SError(riskApiData, response, err);
         }
     }
@@ -77,13 +77,13 @@ export class PostRiskApiClientBase {
         const headersWithoutSensitive = removeSensitiveHeaders(headers, this.config.sensitiveHeaders);
         return toHeaderEntryArray(headersWithoutSensitive);
     }
-    async sendRiskActivity(riskActivity, riskApiData) {
+    async sendRiskActivity(riskActivity, riskApiData, context) {
         const url = this.getRiskUrl();
         const headers = this.getRiskHeaders();
         const body = JSON.stringify(riskActivity);
         const method = HttpMethod.POST;
         const riskRequest = new OutgoingRequestImpl({ url, method, headers, body });
-        this.config.logger.debug(`sending risk api to ${url}`);
+        context.logger.debug(`sending risk api to ${url}`);
         const startTime = Date.now();
         const response = await this.httpClient.send(riskRequest, { timeoutMs: this.config.s2sTimeout });
         const endTime = Date.now();

package/lib/esm/risk_token/parser/TokenParserBase.js

@@ -13,33 +13,34 @@ export class TokenParserBase {
         const tokenData = this.initializeToken(context);
         try {
             if (!tokenData.token) {
-                this.config.logger.debug('no token found');
+                context.logger.debug('no token found');
                 await this.handleMobileErrorIfNeeded(context, tokenData);
                 return tokenData;
             }
             tokenData.tokenParseResult = await tokenData.token.verify(context);
         }
         catch (e) {
-            this.config.logger.debug(`could not parse token - ${e}`);
+            context.logger.debug(`could not parse token - ${e}`);
             tokenData.tokenParseResult = tokenData.token ? TokenParseResult.DECRYPTION_FAILED : TokenParseResult.NONE;
         }
         return tokenData;
     }
-    initializeToken({ requestData, isMobile }) {
-        if (isMobile) {
-            return this.createMobileTokenData(requestData);
+    initializeToken(context) {
+        if (context.isMobile) {
+            return this.createMobileTokenData(context);
         }
         else {
-            return this.createWebTokenData(requestData.cookies);
+            return this.createWebTokenData(context.requestData.cookies);
         }
     }
-    createMobileTokenData({ request }) {
+    createMobileTokenData(context) {
+        const { requestData: { request }, } = context;
         const mobileToken = request.headers.get(X_PX_AUTHORIZATION_HEADER_NAME);
         const tokenData = {
             tokenParseResult: TokenParseResult.NONE,
-            token: this.getMobileToken(mobileToken),
+            token: this.getMobileToken(mobileToken, context),
             mobileData: {
-                originalToken: this.getMobileToken(request.headers.get(X_PX_ORIGINAL_TOKEN_HEADER_NAME)),
+                originalToken: this.getMobileToken(request.headers.get(X_PX_ORIGINAL_TOKEN_HEADER_NAME), context),
                 bypassReason: request.headers.get(X_PX_BYPASS_REASON_HEADER_NAME) || '',
             },
         };
@@ -48,7 +49,7 @@ export class TokenParserBase {
         }
         return tokenData;
     }
-    getMobileToken(mobileToken) {
+    getMobileToken(mobileToken, context) {
         try {
             if (!mobileToken || mobileToken?.indexOf(COOKIE_SPLIT_DELIMITER) === -1) {
                 return null;
@@ -61,7 +62,7 @@ export class TokenParserBase {
             return this.createToken(this.config, { [cookieName]: cookieString.join(COOKIE_SPLIT_DELIMITER) }, this.options);
         }
         catch (e) {
-            this.config.logger.debug(`error extracting mobile token - ${e}, token: ${mobileToken}`);
+            context.logger.debug(`error extracting mobile token - ${e}, token: ${mobileToken}`);
             return null;
         }
     }

package/lib/esm/risk_token/token/v2/DefaultTokenV2.js

@@ -15,13 +15,13 @@ export class DefaultTokenV2 extends TokenBase {
         try {
             const payload = this.decode(this.cookieString);
             if (payload?.t == null || payload?.h == null || payload?.u == null || payload?.v == null) {
-                this.config.logger.debug(`missing cookie v2 fields: ${JSON.stringify(payload)}`);
+                context.logger.debug(`missing cookie v2 fields: ${JSON.stringify(payload)}`);
                 return null;
             }
             return payload;
         }
         catch (e) {
-            this.config.logger.debug(`cookie v2 decryption failed: ${e}`);
+            context.logger.debug(`cookie v2 decryption failed: ${e}`);
         }
         return null;
     }
@@ -30,7 +30,7 @@ export class DefaultTokenV2 extends TokenBase {
             !isValidUuid(this.payload.v) ||
             !isValidUuid(this.payload.u) ||
             !this.payload.h) {
-            this.config.logger.debug(`invalid cookie v2 structure: ${JSON.stringify(this.payload)}`);
+            context.logger.debug(`invalid cookie v2 structure: ${JSON.stringify(this.payload)}`);
             return false;
         }
         try {
@@ -45,10 +45,10 @@ export class DefaultTokenV2 extends TokenBase {
                 this.isHighRisk = true;
                 return true;
             }
-            this.config.logger.debug(`unknown cookie v2 hmac (${this.payload.h}), does not match pass (${passHmac}) or block (${blockHmac})`);
+            context.logger.debug(`unknown cookie v2 hmac (${this.payload.h}), does not match pass (${passHmac}) or block (${blockHmac})`);
         }
         catch (e) {
-            this.config.logger.debug(`cookie v2 validation caught error: ${e}`);
+            context.logger.debug(`cookie v2 validation caught error: ${e}`);
         }
         return false;
     }

package/lib/esm/risk_token/token/v3/DefaultTokenV3.js

@@ -22,7 +22,7 @@ export class DefaultTokenV3 extends TokenBase {
         try {
             const data = this.cookieString.split(COOKIE_SPLIT_DELIMITER);
             if (data.length !== COOKIE_V3_PARTS_COUNT) {
-                this.config.logger.debug(`invalid cookie v3 structure: ${data}`);
+                context.logger.debug(`invalid cookie v3 structure: ${data}`);
                 return null;
             }
             this.hash = data[COOKIE_V3_HMAC_INDEX];
@@ -32,29 +32,29 @@ export class DefaultTokenV3 extends TokenBase {
                 : Number(data[COOKIE_V3_ITERATIONS_INDEX]);
             const encryptedCookie = data[COOKIE_V3_PAYLOAD_INDEX];
             if (!iterations || iterations > this.maxIterations || iterations < this.minIterations) {
-                this.config.logger.debug(`invalid cookie v3 iterations: ${iterations} is not between ${this.minIterations} and ${this.maxIterations}`);
+                context.logger.debug(`invalid cookie v3 iterations: ${iterations} is not between ${this.minIterations} and ${this.maxIterations}`);
                 return null;
             }
             if (!salt || typeof salt !== 'string' || salt.length > COOKIE_V3_MAXIMUM_SALT_LENGTH) {
-                this.config.logger.debug(`invalid cookie v3 salt: ${salt}`);
+                context.logger.debug(`invalid cookie v3 salt: ${salt}`);
                 return null;
             }
             if (!encryptedCookie || typeof encryptedCookie !== 'string') {
-                this.config.logger.debug(`invalid cookie v3 encrypted payload: ${encryptedCookie}`);
+                context.logger.debug(`invalid cookie v3 encrypted payload: ${encryptedCookie}`);
                 return null;
             }
-            return await this.decryptPayload(encryptedCookie, salt, iterations);
+            return await this.decryptPayload(encryptedCookie, salt, iterations, context);
         }
         catch (e) {
-            this.config.logger.debug(`cookie v3 decryption failed: ${e}`);
+            context.logger.debug(`cookie v3 decryption failed: ${e}`);
         }
         return null;
     }
-    async decryptPayload(encryptedCookie, salt, iterations) {
+    async decryptPayload(encryptedCookie, salt, iterations, context) {
         try {
             const decryptedCookie = await this.cipherUtils.pbkdf2Decrypt(this.cookieSecret, encryptedCookie, iterations, salt);
             if (!decryptedCookie) {
-                this.config.logger.debug(`cookie v3 decryption returned falsy value: ${decryptedCookie}`);
+                context.logger.debug(`cookie v3 decryption returned falsy value: ${decryptedCookie}`);
                 return null;
             }
             const payload = JSON.parse(decryptedCookie);
@@ -63,13 +63,13 @@ export class DefaultTokenV3 extends TokenBase {
                 payload?.t == null ||
                 payload?.u == null ||
                 payload?.v == null) {
-                this.config.logger.debug(`invalid cookie v3 structure: ${JSON.stringify(payload)}`);
+                context.logger.debug(`invalid cookie v3 structure: ${JSON.stringify(payload)}`);
                 return null;
             }
             return payload;
         }
         catch (e) {
-            this.config.logger.debug(`error decrypting cookie v3: ${e}`);
+            context.logger.debug(`error decrypting cookie v3: ${e}`);
             return null;
         }
     }
@@ -82,7 +82,7 @@ export class DefaultTokenV3 extends TokenBase {
             return hash === this.hmac;
         }
         catch (e) {
-            this.config.logger.debug(`error validating cookie v3: ${e}`);
+            context.logger.debug(`error validating cookie v3: ${e}`);
             return false;
         }
     }

package/lib/esm/sensitive_request/SensitiveRequestUtils.js

@@ -4,7 +4,7 @@ export var SensitiveRequestUtils;
     SensitiveRequestUtils.isSensitiveRequest = async (config, context) => {
         return (SensitiveRequestUtils.isSensitiveRoute(context.requestData.url, config.sensitiveRoutes) ||
             SensitiveRequestUtils.isSensitiveGraphqlOperation(context.graphqlData) ||
-            (await SensitiveRequestUtils.invokeCustomIsSensitiveRequest(config, context.requestData.request)));
+            (await SensitiveRequestUtils.invokeCustomIsSensitiveRequest(config, context)));
     };
     SensitiveRequestUtils.isSensitiveRoute = (url, sensitiveRoutes) => {
         return isRouteInPatterns(url.pathname, sensitiveRoutes);
@@ -12,13 +12,13 @@ export var SensitiveRequestUtils;
     SensitiveRequestUtils.isSensitiveGraphqlOperation = (graphQLData) => {
         return !!graphQLData?.some((operation) => operation.sensitive);
     };
-    SensitiveRequestUtils.invokeCustomIsSensitiveRequest = async (config, request) => {
+    SensitiveRequestUtils.invokeCustomIsSensitiveRequest = async (config, context) => {
         if (config.customIsSensitiveRequest && typeof config.customIsSensitiveRequest === 'function') {
             try {
-                return await config.customIsSensitiveRequest(request.getUnderlyingRequest());
+                return await config.customIsSensitiveRequest(context.requestData.request.getUnderlyingRequest());
             }
             catch (err) {
-                config.logger.debug(`caught custom sensitive request error - ${err}`);
+                context.logger.debug(`caught custom sensitive request error - ${err}`);
             }
         }
         return false;

package/lib/esm/telemetry/DefaultTelemetry.js

@@ -14,10 +14,10 @@ export class DefaultTelemetry {
     async isValidTelemetryRequest(context) {
         try {
             const telemetryHeader = this.getTelemetryHeader(context);
-            return !!telemetryHeader && (await this.isTelemetryHeaderValid(telemetryHeader));
+            return !!telemetryHeader && (await this.isTelemetryHeaderValid(telemetryHeader, context));
         }
         catch (e) {
-            this.config.logger.debug(`error validating telemetry - ${e}`);
+            context.logger.debug(`error validating telemetry - ${e}`);
             return false;
         }
     }
@@ -26,19 +26,19 @@ export class DefaultTelemetry {
             await this.sendTelemetryActivity(context);
         }
         catch (e) {
-            this.config.logger.debug(`error sending telemetry - ${e}`);
+            context.logger.debug(`error sending telemetry - ${e}`);
         }
     }
     getTelemetryHeader(context) {
         return context.requestData.request.headers.get(TELEMETRY_HEADER_NAME) || '';
     }
-    async isTelemetryHeaderValid(headerValue) {
-        this.config.logger.debug('received command to send enforcer telemetry');
-        return this.timestampHmacHeaderValidator.isValid(headerValue);
+    async isTelemetryHeaderValid(headerValue, context) {
+        context.logger.debug('received command to send enforcer telemetry');
+        return this.timestampHmacHeaderValidator.isValid(headerValue, context.logger);
     }
     async sendTelemetryActivity(context) {
         const telemetryRequest = this.createTelemetryRequest(context);
-        this.config.logger.debug(`sending telemetry to ${telemetryRequest.url}`);
+        context.logger.debug(`sending telemetry to ${telemetryRequest.url}`);
         await this.httpClient.send(telemetryRequest);
     }
     createTelemetryRequest(context) {

package/lib/esm/utils/constants.js

@@ -10,4 +10,4 @@ export const PUSH_DATA_HMAC_HEADER_NAME = 'x-px-pushdata';
 export const PUSH_DATA_FEATURE_HEADER_NAME = 'x-px-feature';
 export const EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
 export const URL_REGEX = /^(https?\:)\/\/(([^@\s:]+):?([^@\s]*)@)?(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/;
-export const CORE_MODULE_VERSION = 'JS Core 0.15.2';
+export const CORE_MODULE_VERSION = 'JS Core 0.16.0';