@workleap/logrocket 1.0.0 → 1.1.0

package/dist/registerLogRocketInstrumentation.js

@@ -1,4 +1,5 @@
-import { getBootstrappingStore, getTelemetryContext } from "@workleap/telemetry";
+import { createCompositeLogger } from "@workleap/logging";
+import { createBootstrappingStore, createTelemetryContext } from "@workleap/telemetry";
 import logrocket from "logrocket";
 import logrocket_fuzzy_search_sanitizer from "logrocket-fuzzy-search-sanitizer";
 import { applyTransformers } from "./applyTransformers.js";
@@ -8,6 +9,8 @@ import { createResponseSanitizer } from "./createResponseSanitizer.js";
 import { createUrlSanitizer } from "./createUrlSanitizer.js";
 import { HasExecutedGuard } from "./HasExecutedGuard.js";
 
+;// CONCATENATED MODULE: external "@workleap/logging"
+
 ;// CONCATENATED MODULE: external "@workleap/telemetry"
 
 ;// CONCATENATED MODULE: external "logrocket"
@@ -36,7 +39,8 @@ import { HasExecutedGuard } from "./HasExecutedGuard.js";
 
 
 
-const IsRegisteredFunctionName = "__WLP_LOGROCKET_INSTRUMENTATION_IS_REGISTERED__";
+
+const IsRegisteredVariableName = "__WLP_LOGROCKET_INSTRUMENTATION_IS_REGISTERED__";
 const RegisterGetSessionUrlFunctionName = "__WLP_LOGROCKET_INSTRUMENTATION_REGISTER_GET_SESSION_URL_LISTENER__";
 const DefaultPrivateFieldNames = [
     "email",
@@ -57,8 +61,8 @@ const DefaultPrivateQueryParameterNames = [
     "password"
 ];
 // The function return type is mandatory, otherwise we got an error TS4058.
-function getLogRocketSdkOptions(options) {
-    const { rootHostname = "workleap.com", privateFieldNames = [], privateQueryParameterNames = [], verbose = false, transformers = [] } = options;
+function getLogRocketSdkOptions(userOptions, logger) {
+    const { rootHostname = "workleap.com", privateFieldNames = [], privateQueryParameterNames = [], verbose = false, transformers = [] } = userOptions;
     const mergedPrivateFieldNames = DefaultPrivateFieldNames.concat(privateFieldNames);
     const mergedPrivateQueryParameterNames = DefaultPrivateQueryParameterNames.concat(privateQueryParameterNames);
     // The "LogrocketFuzzySearch.setup" code is awkward. For now, we prefer to play it safe and call it once here, then forward the sanitize functions
@@ -69,6 +73,8 @@ function getLogRocketSdkOptions(options) {
     const { requestSanitizer: fuzzyRequestSanitizer, responseSanitizer: fuzzyResponseSanitizer } = logrocket_fuzzy_search_sanitizer.setup(mergedPrivateFieldNames);
     const sdkOptions = {
         console: {
+            // Prevent console logs from being visible in LogRocket session replays and leaking PII.
+            // To capture logs in a session replay, use the LogRocketLogger class.
             isEnabled: false
         },
         rootHostname,
@@ -86,7 +92,8 @@ function getLogRocketSdkOptions(options) {
         shouldDebugLog: verbose
     };
     return applyTransformers(sdkOptions, transformers, {
-        verbose
+        verbose,
+        logger
     });
 }
 const registrationGuard = new HasExecutedGuard();
@@ -95,27 +102,24 @@ function __resetRegistrationGuard() {
     registrationGuard.reset();
 }
 /**
- * @see https://workleap.github.io/wl-telemetry
+ * @see {@link https://workleap.github.io/wl-telemetry}
  */ function registerLogRocketInstrumentation(appId, options = {}) {
-    const { verbose = false } = options;
+    const { verbose = false, loggers = [] } = options;
+    const logger = createCompositeLogger(verbose, loggers);
     registrationGuard.throw("[logrocket] The LogRocket instrumentation has already been registered. Did you call the \"registerLogRocketInstrumentation\" function twice?");
-    const sdkOptions = getLogRocketSdkOptions(options);
+    const sdkOptions = getLogRocketSdkOptions(options, logger);
     // Session starts anonymously when LogRocket.init() is called.
     logrocket.init(appId, sdkOptions);
-    const telemetryContext = getTelemetryContext({
-        verbose
-    });
+    const telemetryContext = createTelemetryContext(logger);
     // LogRocket maintains the same session even if the user starts as anonymous and later becomes identified via LogRocket.identify().
     // If LogRocket.identify is called multiple times during a recording, you can search for any of the identified users in the session.
     logrocket.identify(telemetryContext.deviceId, {
         [DeviceIdTrait]: telemetryContext.deviceId,
         [TelemetryIdTrait]: telemetryContext.telemetryId
     });
-    if (verbose) {
-        logrocket.getSessionURL((url)=>{
-            console.log("[logrocket] Session replay URL is now available:", url);
-        });
-    }
+    logrocket.getSessionURL((url)=>{
+        logger.withText("[logrocket] Session replay URL is now available:").withText(url).debug();
+    });
     // Indicates to the host applications that logrocket has been initialized.
     // It's useful in cases where an "add-on", like the platform widgets needs
     // to know whether or not the host application is using LogRocket.
@@ -124,7 +128,7 @@ function __resetRegistrationGuard() {
     // which is great for DX.
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    globalThis[IsRegisteredFunctionName] = true;
+    globalThis[IsRegisteredVariableName] = true;
     // While consumers could directly call LogRocket.getSessionURL, by doing it this way,
     // it allow consumers to not take a direct dependency on the "logrocket" package.
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -132,15 +136,14 @@ function __resetRegistrationGuard() {
     globalThis[RegisterGetSessionUrlFunctionName] = (listener)=>{
         logrocket.getSessionURL(listener);
     };
+    const bootstrappingStore = createBootstrappingStore(logger);
     // Let the other telemetry libraries know that LogRocket instrumentation is ready.
-    getBootstrappingStore().dispatch({
+    bootstrappingStore.dispatch({
         type: "logrocket-ready"
     });
-    if (verbose) {
-        console.log("[logrocket] LogRocket instrumentation is registered.");
-    }
+    logger.debug("[logrocket] LogRocket instrumentation is registered.");
 }
 
-export { IsRegisteredFunctionName, RegisterGetSessionUrlFunctionName, __resetRegistrationGuard, getLogRocketSdkOptions, registerLogRocketInstrumentation };
+export { IsRegisteredVariableName, RegisterGetSessionUrlFunctionName, __resetRegistrationGuard, getLogRocketSdkOptions, registerLogRocketInstrumentation };
 
 //# sourceMappingURL=registerLogRocketInstrumentation.js.map

package/dist/registerLogRocketInstrumentation.js.map

@@ -1 +1 @@
-{"version":3,"file":"registerLogRocketInstrumentation.js","sources":["webpack://@workleap/logrocket/./src/registerLogRocketInstrumentation.ts"],"sourcesContent":["import { getBootstrappingStore, getTelemetryContext } from \"@workleap/telemetry\";\nimport LogRocket from \"logrocket\";\nimport LogrocketFuzzySanitizer from \"logrocket-fuzzy-search-sanitizer\";\nimport { applyTransformers, type LogRocketSdkOptionsTransformer } from \"./applyTransformers.ts\";\nimport { DeviceIdTrait, TelemetryIdTrait } from \"./createDefaultUserTraits.ts\";\nimport { createRequestSanitizer } from \"./createRequestSanitizer.ts\";\nimport { createResponseSanitizer } from \"./createResponseSanitizer.ts\";\nimport { createUrlSanitizer } from \"./createUrlSanitizer.ts\";\nimport { HasExecutedGuard } from \"./HasExecutedGuard.ts\";\nimport type { LogRocketSdkOptions } from \"./logRocketTypes.ts\";\n\nexport const IsRegisteredFunctionName = \"__WLP_LOGROCKET_INSTRUMENTATION_IS_REGISTERED__\";\nexport const RegisterGetSessionUrlFunctionName = \"__WLP_LOGROCKET_INSTRUMENTATION_REGISTER_GET_SESSION_URL_LISTENER__\";\n\nconst DefaultPrivateFieldNames = [\n    \"email\",\n    \"personalEmail\",\n    \"phoneNumber\",\n    \"password\",\n    \"firstName\",\n    \"lastName\",\n    \"givenName\",\n    \"fullName\",\n    \"gender\",\n    \"timeZone\",\n    \"birthday\"\n];\n\nconst DefaultPrivateQueryParameterNames = [\n    \"token\",\n    \"email\",\n    \"password\"\n];\n\n/**\n * @see https://workleap.github.io/wl-telemetry\n */\nexport interface RegisterLogRocketInstrumentationOptions {\n    // Set to capture traffic from all subdomains under one session: https://docs.logrocket.com/reference/roothostname.\n    rootHostname?: LogRocketSdkOptions[\"rootHostname\"];\n    privateFieldNames?: string[];\n    privateQueryParameterNames?: string[];\n    verbose?: boolean;\n    transformers?: LogRocketSdkOptionsTransformer[];\n}\n\n// The function return type is mandatory, otherwise we got an error TS4058.\nexport function getLogRocketSdkOptions(options: RegisterLogRocketInstrumentationOptions): LogRocketSdkOptions {\n    const {\n        rootHostname = \"workleap.com\",\n        privateFieldNames = [],\n        privateQueryParameterNames = [],\n        verbose = false,\n        transformers = []\n    } = options;\n\n    const mergedPrivateFieldNames = DefaultPrivateFieldNames.concat(privateFieldNames);\n    const mergedPrivateQueryParameterNames = DefaultPrivateQueryParameterNames.concat(privateQueryParameterNames);\n\n    // The \"LogrocketFuzzySearch.setup\" code is awkward. For now, we prefer to play it safe and call it once here, then forward the sanitize functions\n    // to the appropriate factories.\n    // No clue why the \"setup\" method is not available. This package is shady.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    const { requestSanitizer: fuzzyRequestSanitizer, responseSanitizer: fuzzyResponseSanitizer } = LogrocketFuzzySanitizer.setup(mergedPrivateFieldNames);\n\n    const sdkOptions = {\n        console: {\n            isEnabled: false\n        },\n        rootHostname,\n        dom: {\n            textSanitizer: true,\n            inputSanitizer: true\n        },\n        network: {\n            requestSanitizer: createRequestSanitizer(fuzzyRequestSanitizer),\n            responseSanitizer: createResponseSanitizer(fuzzyResponseSanitizer)\n        },\n        browser: {\n            urlSanitizer: createUrlSanitizer(mergedPrivateQueryParameterNames)\n        },\n        shouldDebugLog: verbose\n    } satisfies LogRocketSdkOptions;\n\n    return applyTransformers(sdkOptions, transformers, {\n        verbose\n    });\n}\n\nconst registrationGuard = new HasExecutedGuard();\n\n// This function should only be used by tests.\nexport function __resetRegistrationGuard() {\n    registrationGuard.reset();\n}\n\n/**\n * @see https://workleap.github.io/wl-telemetry\n */\nexport function registerLogRocketInstrumentation(appId: string, options: RegisterLogRocketInstrumentationOptions = {}) {\n    const {\n        verbose = false\n    } = options;\n\n    registrationGuard.throw(\"[logrocket] The LogRocket instrumentation has already been registered. Did you call the \\\"registerLogRocketInstrumentation\\\" function twice?\");\n\n    const sdkOptions = getLogRocketSdkOptions(options);\n\n    // Session starts anonymously when LogRocket.init() is called.\n    LogRocket.init(appId, sdkOptions);\n\n    const telemetryContext = getTelemetryContext({ verbose });\n\n    // LogRocket maintains the same session even if the user starts as anonymous and later becomes identified via LogRocket.identify().\n    // If LogRocket.identify is called multiple times during a recording, you can search for any of the identified users in the session.\n    LogRocket.identify(telemetryContext.deviceId, {\n        [DeviceIdTrait]: telemetryContext.deviceId,\n        [TelemetryIdTrait]: telemetryContext.telemetryId\n    });\n\n    if (verbose) {\n        LogRocket.getSessionURL(url => {\n            console.log(\"[logrocket] Session replay URL is now available:\", url);\n        });\n    }\n\n    // Indicates to the host applications that logrocket has been initialized.\n    // It's useful in cases where an \"add-on\", like the platform widgets needs\n    // to know whether or not the host application is using LogRocket.\n    // While there are ways that the host application could tell to an \"add-on\" if\n    // it's using LogRocket or not, doing it this way is transparent for the consumer,\n    // which is great for DX.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    globalThis[IsRegisteredFunctionName] = true;\n\n    // While consumers could directly call LogRocket.getSessionURL, by doing it this way,\n    // it allow consumers to not take a direct dependency on the \"logrocket\" package.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    globalThis[RegisterGetSessionUrlFunctionName] = listener => {\n        LogRocket.getSessionURL(listener);\n    };\n\n    // Let the other telemetry libraries know that LogRocket instrumentation is ready.\n    getBootstrappingStore().dispatch({ type: \"logrocket-ready\" });\n\n    if (verbose) {\n        console.log(\"[logrocket] LogRocket instrumentation is registered.\");\n    }\n}\n"],"names":["getBootstrappingStore","getTelemetryContext","LogRocket","LogrocketFuzzySanitizer","applyTransformers","DeviceIdTrait","TelemetryIdTrait","createRequestSanitizer","createResponseSanitizer","createUrlSanitizer","HasExecutedGuard","IsRegisteredFunctionName","RegisterGetSessionUrlFunctionName","DefaultPrivateFieldNames","DefaultPrivateQueryParameterNames","getLogRocketSdkOptions","options","rootHostname","privateFieldNames","privateQueryParameterNames","verbose","transformers","mergedPrivateFieldNames","mergedPrivateQueryParameterNames","fuzzyRequestSanitizer","fuzzyResponseSanitizer","sdkOptions","registrationGuard","__resetRegistrationGuard","registerLogRocketInstrumentation","appId","telemetryContext","url","console","globalThis","listener"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAiF;AAC/C;AACqC;AACyB;AACjB;AACV;AACE;AACV;AACJ;AAGlD,MAAMW,2BAA2B,kDAAkD;AACnF,MAAMC,oCAAoC,sEAAsE;AAEvH,MAAMC,2BAA2B;IAC7B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACH;AAED,MAAMC,oCAAoC;IACtC;IACA;IACA;CACH;AAcD,2EAA2E;AACpE,SAASC,uBAAuBC,OAAgD;IACnF,MAAM,EACFC,eAAe,cAAc,EAC7BC,oBAAoB,EAAE,EACtBC,6BAA6B,EAAE,EAC/BC,UAAU,KAAK,EACfC,eAAe,EAAE,EACpB,GAAGL;IAEJ,MAAMM,0BAA0BT,yBAAyB,MAAM,CAACK;IAChE,MAAMK,mCAAmCT,kCAAkC,MAAM,CAACK;IAElF,kJAAkJ;IAClJ,gCAAgC;IAChC,0EAA0E;IAC1E,6DAA6D;IAC7D,aAAa;IACb,MAAM,EAAE,kBAAkBK,qBAAqB,EAAE,mBAAmBC,sBAAsB,EAAE,GAAGtB,sCAA6B,CAACmB;IAE7H,MAAMI,aAAa;QACf,SAAS;YACL,WAAW;QACf;QACAT;QACA,KAAK;YACD,eAAe;YACf,gBAAgB;QACpB;QACA,SAAS;YACL,kBAAkBV,sBAAsBA,CAACiB;YACzC,mBAAmBhB,uBAAuBA,CAACiB;QAC/C;QACA,SAAS;YACL,cAAchB,kBAAkBA,CAACc;QACrC;QACA,gBAAgBH;IACpB;IAEA,OAAOhB,iBAAiBA,CAACsB,YAAYL,cAAc;QAC/CD;IACJ;AACJ;AAEA,MAAMO,oBAAoB,IAAIjB,gBAAgBA;AAE9C,8CAA8C;AACvC,SAASkB;IACZD,kBAAkB,KAAK;AAC3B;AAEA;;CAEC,GACM,SAASE,iCAAiCC,KAAa,EAAEd,UAAmD,CAAC,CAAC;IACjH,MAAM,EACFI,UAAU,KAAK,EAClB,GAAGJ;IAEJW,kBAAkB,KAAK,CAAC;IAExB,MAAMD,aAAaX,uBAAuBC;IAE1C,8DAA8D;IAC9Dd,cAAc,CAAC4B,OAAOJ;IAEtB,MAAMK,mBAAmB9B,mBAAmBA,CAAC;QAAEmB;IAAQ;IAEvD,mIAAmI;IACnI,oIAAoI;IACpIlB,kBAAkB,CAAC6B,iBAAiB,QAAQ,EAAE;QAC1C,CAAC1B,aAAaA,CAAC,EAAE0B,iBAAiB,QAAQ;QAC1C,CAACzB,gBAAgBA,CAAC,EAAEyB,iBAAiB,WAAW;IACpD;IAEA,IAAIX,SAAS;QACTlB,uBAAuB,CAAC8B,CAAAA;YACpBC,QAAQ,GAAG,CAAC,oDAAoDD;QACpE;IACJ;IAEA,0EAA0E;IAC1E,0EAA0E;IAC1E,kEAAkE;IAClE,8EAA8E;IAC9E,kFAAkF;IAClF,yBAAyB;IACzB,6DAA6D;IAC7D,aAAa;IACbE,UAAU,CAACvB,yBAAyB,GAAG;IAEvC,qFAAqF;IACrF,iFAAiF;IACjF,6DAA6D;IAC7D,aAAa;IACbuB,UAAU,CAACtB,kCAAkC,GAAGuB,CAAAA;QAC5CjC,uBAAuB,CAACiC;IAC5B;IAEA,kFAAkF;IAClFnC,qBAAqBA,GAAG,QAAQ,CAAC;QAAE,MAAM;IAAkB;IAE3D,IAAIoB,SAAS;QACTa,QAAQ,GAAG,CAAC;IAChB;AACJ"}
+{"version":3,"file":"registerLogRocketInstrumentation.js","sources":["webpack://@workleap/logrocket/./src/registerLogRocketInstrumentation.ts"],"sourcesContent":["import { createCompositeLogger, type RootLogger } from \"@workleap/logging\";\nimport { createBootstrappingStore, createTelemetryContext } from \"@workleap/telemetry\";\nimport LogRocket from \"logrocket\";\nimport LogrocketFuzzySanitizer from \"logrocket-fuzzy-search-sanitizer\";\nimport { applyTransformers, type LogRocketSdkOptionsTransformer } from \"./applyTransformers.ts\";\nimport { DeviceIdTrait, TelemetryIdTrait } from \"./createDefaultUserTraits.ts\";\nimport { createRequestSanitizer } from \"./createRequestSanitizer.ts\";\nimport { createResponseSanitizer } from \"./createResponseSanitizer.ts\";\nimport { createUrlSanitizer } from \"./createUrlSanitizer.ts\";\nimport { HasExecutedGuard } from \"./HasExecutedGuard.ts\";\nimport type { LogRocketSdkOptions } from \"./logRocketTypes.ts\";\n\nexport const IsRegisteredVariableName = \"__WLP_LOGROCKET_INSTRUMENTATION_IS_REGISTERED__\";\nexport const RegisterGetSessionUrlFunctionName = \"__WLP_LOGROCKET_INSTRUMENTATION_REGISTER_GET_SESSION_URL_LISTENER__\";\n\nconst DefaultPrivateFieldNames = [\n    \"email\",\n    \"personalEmail\",\n    \"phoneNumber\",\n    \"password\",\n    \"firstName\",\n    \"lastName\",\n    \"givenName\",\n    \"fullName\",\n    \"gender\",\n    \"timeZone\",\n    \"birthday\"\n];\n\nconst DefaultPrivateQueryParameterNames = [\n    \"token\",\n    \"email\",\n    \"password\"\n];\n\n/**\n * @see {@link https://workleap.github.io/wl-telemetry}\n */\nexport interface RegisterLogRocketInstrumentationOptions {\n    /**\n     * A root hostname to track sessions across subdomains. Set this option to capture traffic from all subdomains under one session: https://docs.logrocket.com/reference/roothostname.\n     */\n    rootHostname?: LogRocketSdkOptions[\"rootHostname\"];\n    /**\n     * Names of additional fields to exclude from session replays. These fields will be removed from network requests, responses using a fuzzy-matching algorithm.\n     */\n    privateFieldNames?: string[];\n    /**\n     * Names of additional fields to exclude from session replays. These fields will be removed from query parameters using a fuzzy-matching algorithm.\n     */\n    privateQueryParameterNames?: string[];\n    /**\n     * Indicates whether or not debug information should be logged to the console.\n     */\n    verbose?: boolean;\n    /**\n     * The logger instances that will output messages.\n     */\n    loggers?: RootLogger[];\n    /**\n     * Hooks to transform the resulting LogRocket SDK options.\n     */\n    transformers?: LogRocketSdkOptionsTransformer[];\n}\n\n// The function return type is mandatory, otherwise we got an error TS4058.\nexport function getLogRocketSdkOptions(userOptions: RegisterLogRocketInstrumentationOptions, logger: RootLogger): LogRocketSdkOptions {\n    const {\n        rootHostname = \"workleap.com\",\n        privateFieldNames = [],\n        privateQueryParameterNames = [],\n        verbose = false,\n        transformers = []\n    } = userOptions;\n\n    const mergedPrivateFieldNames = DefaultPrivateFieldNames.concat(privateFieldNames);\n    const mergedPrivateQueryParameterNames = DefaultPrivateQueryParameterNames.concat(privateQueryParameterNames);\n\n    // The \"LogrocketFuzzySearch.setup\" code is awkward. For now, we prefer to play it safe and call it once here, then forward the sanitize functions\n    // to the appropriate factories.\n    // No clue why the \"setup\" method is not available. This package is shady.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    const { requestSanitizer: fuzzyRequestSanitizer, responseSanitizer: fuzzyResponseSanitizer } = LogrocketFuzzySanitizer.setup(mergedPrivateFieldNames);\n\n    const sdkOptions = {\n        console: {\n            // Prevent console logs from being visible in LogRocket session replays and leaking PII.\n            // To capture logs in a session replay, use the LogRocketLogger class.\n            isEnabled: false\n        },\n        rootHostname,\n        dom: {\n            textSanitizer: true,\n            inputSanitizer: true\n        },\n        network: {\n            requestSanitizer: createRequestSanitizer(fuzzyRequestSanitizer),\n            responseSanitizer: createResponseSanitizer(fuzzyResponseSanitizer)\n        },\n        browser: {\n            urlSanitizer: createUrlSanitizer(mergedPrivateQueryParameterNames)\n        },\n        shouldDebugLog: verbose\n    } satisfies LogRocketSdkOptions;\n\n    return applyTransformers(sdkOptions, transformers, {\n        verbose,\n        logger\n    });\n}\n\nconst registrationGuard = new HasExecutedGuard();\n\n// This function should only be used by tests.\nexport function __resetRegistrationGuard() {\n    registrationGuard.reset();\n}\n\n/**\n * @see {@link https://workleap.github.io/wl-telemetry}\n */\nexport function registerLogRocketInstrumentation(appId: string, options: RegisterLogRocketInstrumentationOptions = {}) {\n    const {\n        verbose = false,\n        loggers = []\n    } = options;\n\n    const logger = createCompositeLogger(verbose, loggers);\n\n    registrationGuard.throw(\"[logrocket] The LogRocket instrumentation has already been registered. Did you call the \\\"registerLogRocketInstrumentation\\\" function twice?\");\n\n    const sdkOptions = getLogRocketSdkOptions(options, logger);\n\n    // Session starts anonymously when LogRocket.init() is called.\n    LogRocket.init(appId, sdkOptions);\n\n    const telemetryContext = createTelemetryContext(logger);\n\n    // LogRocket maintains the same session even if the user starts as anonymous and later becomes identified via LogRocket.identify().\n    // If LogRocket.identify is called multiple times during a recording, you can search for any of the identified users in the session.\n    LogRocket.identify(telemetryContext.deviceId, {\n        [DeviceIdTrait]: telemetryContext.deviceId,\n        [TelemetryIdTrait]: telemetryContext.telemetryId\n    });\n\n    LogRocket.getSessionURL(url => {\n        logger\n            .withText(\"[logrocket] Session replay URL is now available:\")\n            .withText(url)\n            .debug();\n    });\n\n    // Indicates to the host applications that logrocket has been initialized.\n    // It's useful in cases where an \"add-on\", like the platform widgets needs\n    // to know whether or not the host application is using LogRocket.\n    // While there are ways that the host application could tell to an \"add-on\" if\n    // it's using LogRocket or not, doing it this way is transparent for the consumer,\n    // which is great for DX.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    globalThis[IsRegisteredVariableName] = true;\n\n    // While consumers could directly call LogRocket.getSessionURL, by doing it this way,\n    // it allow consumers to not take a direct dependency on the \"logrocket\" package.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    globalThis[RegisterGetSessionUrlFunctionName] = listener => {\n        LogRocket.getSessionURL(listener);\n    };\n\n    const bootstrappingStore = createBootstrappingStore(logger);\n    // Let the other telemetry libraries know that LogRocket instrumentation is ready.\n    bootstrappingStore.dispatch({ type: \"logrocket-ready\" });\n\n    logger.debug(\"[logrocket] LogRocket instrumentation is registered.\");\n}\n"],"names":["createCompositeLogger","createBootstrappingStore","createTelemetryContext","LogRocket","LogrocketFuzzySanitizer","applyTransformers","DeviceIdTrait","TelemetryIdTrait","createRequestSanitizer","createResponseSanitizer","createUrlSanitizer","HasExecutedGuard","IsRegisteredVariableName","RegisterGetSessionUrlFunctionName","DefaultPrivateFieldNames","DefaultPrivateQueryParameterNames","getLogRocketSdkOptions","userOptions","logger","rootHostname","privateFieldNames","privateQueryParameterNames","verbose","transformers","mergedPrivateFieldNames","mergedPrivateQueryParameterNames","fuzzyRequestSanitizer","fuzzyResponseSanitizer","sdkOptions","registrationGuard","__resetRegistrationGuard","registerLogRocketInstrumentation","appId","options","loggers","telemetryContext","url","globalThis","listener","bootstrappingStore"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA2E;AACY;AACrD;AACqC;AACyB;AACjB;AACV;AACE;AACV;AACJ;AAGlD,MAAMY,2BAA2B,kDAAkD;AACnF,MAAMC,oCAAoC,sEAAsE;AAEvH,MAAMC,2BAA2B;IAC7B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACH;AAED,MAAMC,oCAAoC;IACtC;IACA;IACA;CACH;AAgCD,2EAA2E;AACpE,SAASC,uBAAuBC,WAAoD,EAAEC,MAAkB;IAC3G,MAAM,EACFC,eAAe,cAAc,EAC7BC,oBAAoB,EAAE,EACtBC,6BAA6B,EAAE,EAC/BC,UAAU,KAAK,EACfC,eAAe,EAAE,EACpB,GAAGN;IAEJ,MAAMO,0BAA0BV,yBAAyB,MAAM,CAACM;IAChE,MAAMK,mCAAmCV,kCAAkC,MAAM,CAACM;IAElF,kJAAkJ;IAClJ,gCAAgC;IAChC,0EAA0E;IAC1E,6DAA6D;IAC7D,aAAa;IACb,MAAM,EAAE,kBAAkBK,qBAAqB,EAAE,mBAAmBC,sBAAsB,EAAE,GAAGvB,sCAA6B,CAACoB;IAE7H,MAAMI,aAAa;QACf,SAAS;YACL,wFAAwF;YACxF,sEAAsE;YACtE,WAAW;QACf;QACAT;QACA,KAAK;YACD,eAAe;YACf,gBAAgB;QACpB;QACA,SAAS;YACL,kBAAkBX,sBAAsBA,CAACkB;YACzC,mBAAmBjB,uBAAuBA,CAACkB;QAC/C;QACA,SAAS;YACL,cAAcjB,kBAAkBA,CAACe;QACrC;QACA,gBAAgBH;IACpB;IAEA,OAAOjB,iBAAiBA,CAACuB,YAAYL,cAAc;QAC/CD;QACAJ;IACJ;AACJ;AAEA,MAAMW,oBAAoB,IAAIlB,gBAAgBA;AAE9C,8CAA8C;AACvC,SAASmB;IACZD,kBAAkB,KAAK;AAC3B;AAEA;;CAEC,GACM,SAASE,iCAAiCC,KAAa,EAAEC,UAAmD,CAAC,CAAC;IACjH,MAAM,EACFX,UAAU,KAAK,EACfY,UAAU,EAAE,EACf,GAAGD;IAEJ,MAAMf,SAASlB,qBAAqBA,CAACsB,SAASY;IAE9CL,kBAAkB,KAAK,CAAC;IAExB,MAAMD,aAAaZ,uBAAuBiB,SAASf;IAEnD,8DAA8D;IAC9Df,cAAc,CAAC6B,OAAOJ;IAEtB,MAAMO,mBAAmBjC,sBAAsBA,CAACgB;IAEhD,mIAAmI;IACnI,oIAAoI;IACpIf,kBAAkB,CAACgC,iBAAiB,QAAQ,EAAE;QAC1C,CAAC7B,aAAaA,CAAC,EAAE6B,iBAAiB,QAAQ;QAC1C,CAAC5B,gBAAgBA,CAAC,EAAE4B,iBAAiB,WAAW;IACpD;IAEAhC,uBAAuB,CAACiC,CAAAA;QACpBlB,OACK,QAAQ,CAAC,oDACT,QAAQ,CAACkB,KACT,KAAK;IACd;IAEA,0EAA0E;IAC1E,0EAA0E;IAC1E,kEAAkE;IAClE,8EAA8E;IAC9E,kFAAkF;IAClF,yBAAyB;IACzB,6DAA6D;IAC7D,aAAa;IACbC,UAAU,CAACzB,yBAAyB,GAAG;IAEvC,qFAAqF;IACrF,iFAAiF;IACjF,6DAA6D;IAC7D,aAAa;IACbyB,UAAU,CAACxB,kCAAkC,GAAGyB,CAAAA;QAC5CnC,uBAAuB,CAACmC;IAC5B;IAEA,MAAMC,qBAAqBtC,wBAAwBA,CAACiB;IACpD,kFAAkF;IAClFqB,mBAAmB,QAAQ,CAAC;QAAE,MAAM;IAAkB;IAEtDrB,OAAO,KAAK,CAAC;AACjB"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@workleap/logrocket",
   "author": "Workleap",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A package containing utilities for LogRocket.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,11 +28,12 @@
     "README.md"
   ],
   "peerDependencies": {
-    "logrocket": "^10.1.0",
-    "@workleap/telemetry": "1.0.0"
+    "logrocket": "^10.1.0"
   },
   "dependencies": {
-    "logrocket-fuzzy-search-sanitizer": "0.0.2"
+    "@workleap/logging": "^1.0.2",
+    "logrocket-fuzzy-search-sanitizer": "0.0.2",
+    "@workleap/telemetry": "1.1.0"
   },
   "devDependencies": {
     "@rsbuild/core": "1.4.6",

package/src/LogRocketLogger.ts

@@ -0,0 +1,353 @@
+import { type Logger, type LoggerOptions, type LoggerScope, type LoggerScopeEndOptions, LogLevel, type LogOptions, type Segment } from "@workleap/logging";
+import LogRocket from "logrocket";
+
+type LogFunction = (...rest: unknown[]) => void;
+type PendingLog = () => void;
+
+function parseSegments(segments: Segment[]) {
+    return segments.reduce<unknown[]>((acc, x) => {
+        if (x.text) {
+            acc.push(x.text);
+        } else if (x.obj) {
+            acc.push(x.obj);
+        } else if (x.error) {
+            acc.push(x.error);
+        }
+
+        return acc;
+    }, []);
+}
+
+/**
+ * An scope implementation for the LogRocket logger.
+ * @see {@link https://workleap.github.io/wl-telemetry}
+ */
+export class LogRocketLoggerScope implements LoggerScope {
+    readonly #logLevel: LogLevel;
+    readonly #label: string;
+
+    #segments: Segment[] = [];
+    #pendingLogs: PendingLog[] = [];
+    #hasEnded: boolean = false;
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    constructor(label: string, logLevel: LogLevel) {
+        this.#logLevel = logLevel;
+        this.#label = label;
+    }
+
+    #resetSegments() {
+        this.#segments = [];
+    }
+
+    #log(fct: LogFunction, threshold: LogLevel) {
+        if (this.#segments.length > 0) {
+            if (this.#logLevel <= threshold) {
+                // Required closure to preserved the current log items for when they will be formatted when the scope is ended.
+                const segments = this.#segments;
+
+                this.#pendingLogs.push(() => {
+                    const parsedSegments = parseSegments(segments);
+                    parsedSegments.unshift(`(${this.#label})`);
+
+                    fct(...parsedSegments);
+                });
+            }
+
+            this.#resetSegments();
+        }
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    withText(text: string, options: LogOptions = {}) {
+        this.#segments.push({
+            text,
+            options
+        });
+
+        return this;
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    withError(error: Error) {
+        this.#segments.push({
+            error
+        });
+
+        return this;
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    withObject(obj: object) {
+        this.#segments.push({
+            obj
+        });
+
+        return this;
+    }
+
+    /**
+     * Write a debug log. The log will be processed only if the logger LogLevel is >= debug.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    debug(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.log, LogLevel.debug);
+    }
+
+    /**
+     * Write an information log. The log will be processed only if the logger LogLevel is >= information.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    information(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.log, LogLevel.information);
+    }
+
+    /**
+     * Write a warning log. The log will be processed only if the logger LogLevel is >= warning.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    warning(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.warn, LogLevel.warning);
+    }
+
+    /**
+     * Write an error log. The log will be processed only if the logger LogLevel is >= error.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    error(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.error, LogLevel.error);
+    }
+
+    /**
+     * Write a critical log. The log will be processed only if the logger LogLevel is >= critical.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    critical(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.error, LogLevel.critical);
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    end(options: LoggerScopeEndOptions = {}) {
+        const {
+            dismiss = false
+        } = options;
+
+        if (!this.#hasEnded) {
+            this.#hasEnded = true;
+
+            if (!dismiss) {
+                if (this.#pendingLogs.length > 0) {
+                    this.#pendingLogs.forEach(x => {
+                        x();
+                    });
+
+                    this.#pendingLogs = [];
+                }
+            }
+        }
+    }
+}
+
+/**
+ * A logger implementation for LogRocket.
+ * @see {@link https://workleap.github.io/wl-telemetry}
+ */
+export class LogRocketLogger implements Logger {
+    readonly #logLevel: LogLevel;
+    #segments: Segment[] = [];
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    constructor(options: LoggerOptions = {}) {
+        const {
+            logLevel = LogLevel.debug
+        } = options;
+
+        this.#logLevel = logLevel;
+    }
+
+    #resetSegments() {
+        this.#segments = [];
+    }
+
+    #log(fct: LogFunction, threshold: LogLevel) {
+        if (this.#segments.length > 0) {
+            if (this.#logLevel <= threshold) {
+                const parsedSegments = parseSegments(this.#segments);
+
+                fct(...parsedSegments);
+            }
+
+            this.#resetSegments();
+        }
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    getName() {
+        return LogRocketLogger.name;
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    withText(text: string, options: LogOptions = {}) {
+        this.#segments.push({
+            text,
+            options
+        });
+
+        return this;
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    withError(error: Error) {
+        this.#segments.push({
+            error
+        });
+
+        return this;
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    withObject(obj: object) {
+        this.#segments.push({
+            obj
+        });
+
+        return this;
+    }
+
+    /**
+     * Write a debug log. The log will be processed only if the logger LogLevel is >= debug.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    debug(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.log, LogLevel.debug);
+    }
+
+    /**
+     * Write an information log. The log will be processed only if the logger LogLevel is >= information.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    information(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.log, LogLevel.information);
+    }
+
+    /**
+     * Write a warning log. The log will be processed only if the logger LogLevel is >= warning.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    warning(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.warn, LogLevel.warning);
+    }
+
+    /**
+     * Write an error log. The log will be processed only if the logger LogLevel is >= error.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    error(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.error, LogLevel.error);
+    }
+
+    /**
+     * Write a critical log. The log will be processed only if the logger LogLevel is >= critical.
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    critical(log?: string, options?: LogOptions) {
+        if (log) {
+            this.#segments.push({
+                text: log,
+                options
+            });
+        }
+
+        this.#log(LogRocket.error, LogLevel.critical);
+    }
+
+    /**
+     * @see {@link https://workleap.github.io/wl-logging}
+     */
+    startScope(label: string) {
+        return new LogRocketLoggerScope(label, this.#logLevel);
+    }
+}

package/src/applyTransformers.ts

@@ -1,12 +1,18 @@
+import type { RootLogger } from "@workleap/logging";
 import type { LogRocketSdkOptions } from "./logRocketTypes.ts";
 
 /**
- * @see https://workleap.github.io/wl-telemetry
+ * @see {@link https://workleap.github.io/wl-telemetry}
  */
 export interface LogRocketSdkOptionsTransformerContext {
     verbose: boolean;
+    logger: RootLogger;
 }
 
+/**
+ * Hook to transform the resulting LogRocket SDK options.
+ * @see {@link https://workleap.github.io/wl-telemetry}
+ */
 export type LogRocketSdkOptionsTransformer = (options: LogRocketSdkOptions, context: LogRocketSdkOptionsTransformerContext) => LogRocketSdkOptions;
 
 // The function return type is mandatory, otherwise we got an error TS4058.

package/src/createDefaultUserTraits.ts

@@ -2,7 +2,7 @@ import { getTelemetryContext } from "@workleap/telemetry";
 import { isDefined } from "./assertions.ts";
 
 /**
- * @see https://workleap.github.io/wl-telemetry
+ * @see {@link https://workleap.github.io/wl-telemetry}
  */
 export interface LogRocketIdentification {
     userId: string;
@@ -40,7 +40,7 @@ export interface LogRocketIdentification {
 }
 
 /**
- * @see https://workleap.github.io/wl-telemetry
+ * @see {@link https://workleap.github.io/wl-telemetry}
  */
 export interface LogRocketUserTraits extends Record<string, unknown> {
     "User Id": string;
@@ -79,7 +79,8 @@ export const DeviceIdTrait = "Device Id";
 export const TelemetryIdTrait = "Telemetry Id";
 
 /**
- * @see https://workleap.github.io/wl-telemetry
+ * Create the default user traits for a WLP user.
+ * @see {@link https://workleap.github.io/wl-telemetry}
  */
 export function createDefaultUserTraits(identification: LogRocketIdentification) {
     const {

package/src/index.ts

@@ -1,5 +1,6 @@
 export type { LogRocketSdkOptionsTransformer } from "./applyTransformers.ts";
 export { createDefaultUserTraits, type LogRocketIdentification, type LogRocketUserTraits } from "./createDefaultUserTraits.ts";
+export { LogRocketLogger, LogRocketLoggerScope } from "./LogRocketLogger.ts";
 export type * from "./logRocketTypes.ts";
 export { registerLogRocketInstrumentation } from "./registerLogRocketInstrumentation.ts";