@squide/firefly 14.0.0 → 15.0.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @squide/firefly
 
+## 15.0.0
+
+### Major Changes
+
+- [#318](https://github.com/workleap/wl-squide/pull/318) [`6bf9a65`](https://github.com/workleap/wl-squide/commit/6bf9a65f222a6201655cf1ee525e94211aabe0b7) Thanks [@patricklafrance](https://github.com/patricklafrance)! - Honeycomb instrumentation is now registered when an Honeycomb client is provided to the `initializeFirefly` function rather than by implicitly using global variables. Also updated dependency versions.
+
+### Patch Changes
+
+- Updated dependencies [[`6bf9a65`](https://github.com/workleap/wl-squide/commit/6bf9a65f222a6201655cf1ee525e94211aabe0b7)]:
+  - @squide/module-federation@7.0.2
+  - @squide/react-router@8.1.1
+  - @squide/core@6.1.1
+  - @squide/msw@4.0.2
+
+## 14.1.0
+
+### Minor Changes
+
+- [#313](https://github.com/workleap/wl-squide/pull/313) [`bea660b`](https://github.com/workleap/wl-squide/commit/bea660bf827dd123a52f6062a7be8865dc99055b) Thanks [@patricklafrance](https://github.com/patricklafrance)! - Hardened Honeycomb integration and added support for React Router relative paths.
+
+### Patch Changes
+
+- Updated dependencies [[`bea660b`](https://github.com/workleap/wl-squide/commit/bea660bf827dd123a52f6062a7be8865dc99055b)]:
+  - @squide/react-router@8.1.0
+  - @squide/core@6.1.0
+  - @squide/module-federation@7.0.1
+  - @squide/msw@4.0.1
+
 ## 14.0.0
 
 ### Major Changes

package/dist/honeycomb/initializeHoneycomb.d.ts

@@ -1,2 +1,3 @@
+import type { HoneycombInstrumentationPartialClient } from "@workleap-telemetry/core";
 import type { FireflyRuntime } from "../FireflyRuntime.tsx";
-export declare function initializeHoneycomb(runtime: FireflyRuntime): Promise<void>;
+export declare function initializeHoneycomb(runtime: FireflyRuntime, honeycombInstrumentationClient?: HoneycombInstrumentationPartialClient): Promise<void>;

package/dist/honeycomb/initializeHoneycomb.js

@@ -1,22 +1,18 @@
-import { canRegisterHoneycombInstrumentation } from "./canRegisterHoneycombInstrumentation.js";
-
-;// CONCATENATED MODULE: external "./canRegisterHoneycombInstrumentation.js"
 
 ;// CONCATENATED MODULE: ./src/honeycomb/initializeHoneycomb.ts
-
-async function initializeHoneycomb(runtime) {
-    if (canRegisterHoneycombInstrumentation()) {
+async function initializeHoneycomb(runtime, honeycombInstrumentationClient) {
+    if (honeycombInstrumentationClient) {
         try {
             // Dynamically import the Honeycomb instrumentation to prevent loading all the Honeycomb libraries
             // if Honeycomb instrumentation is not registered by the hosting application.
             const mod = await import("./registerHoneycombInstrumentation.js");
-            mod.registerHoneycombInstrumentation(runtime);
+            mod.registerHoneycombInstrumentation(runtime, honeycombInstrumentationClient);
         } catch (error) {
-            runtime.logger.error("[squide] Failed to register Honeycomb instrumentation. The \"./registerHoneycombInstrumentation.ts\" cannot be imported.");
+            runtime.logger.error("[squide] Failed to register Honeycomb instrumentation. The \"./registerHoneycombInstrumentation.ts\" file cannot be imported.");
             throw error;
         }
     } else {
-        runtime.logger.information("[squide] Cannot register Honeycomb instrumentation because the host application is not using the \"@workleap/honeycomb\" package.");
+        runtime.logger.information("[squide] Cannot register Honeycomb instrumentation because the host application hasn't provided a client.");
     }
 }
 

package/dist/honeycomb/initializeHoneycomb.js.map

@@ -1 +1 @@
-{"version":3,"file":"honeycomb/initializeHoneycomb.js","sources":["webpack://@squide/firefly/./src/honeycomb/initializeHoneycomb.ts"],"sourcesContent":["import type { FireflyRuntime } from \"../FireflyRuntime.tsx\";\nimport { canRegisterHoneycombInstrumentation } from \"./canRegisterHoneycombInstrumentation.ts\";\n\nexport async function initializeHoneycomb(runtime: FireflyRuntime) {\n    if (canRegisterHoneycombInstrumentation()) {\n        try {\n            // Dynamically import the Honeycomb instrumentation to prevent loading all the Honeycomb libraries\n            // if Honeycomb instrumentation is not registered by the hosting application.\n            const mod = await import(\"./registerHoneycombInstrumentation.ts\");\n\n            mod.registerHoneycombInstrumentation(runtime);\n        } catch (error: unknown) {\n            runtime.logger.error(\"[squide] Failed to register Honeycomb instrumentation. The \\\"./registerHoneycombInstrumentation.ts\\\" cannot be imported.\");\n\n            throw error;\n        }\n    } else {\n        runtime.logger.information(\"[squide] Cannot register Honeycomb instrumentation because the host application is not using the \\\"@workleap/honeycomb\\\" package.\");\n    }\n}\n\n\n"],"names":["canRegisterHoneycombInstrumentation","initializeHoneycomb","runtime","mod","error"],"mappings":";;;;;AAC+F;AAExF,eAAeC,oBAAoBC,OAAuB;IAC7D,IAAIF,mCAAmCA,IAAI;QACvC,IAAI;YACA,kGAAkG;YAClG,6EAA6E;YAC7E,MAAMG,MAAM,MAAM,+CAA+C;YAEjEA,IAAI,gCAAgC,CAACD;QACzC,EAAE,OAAOE,OAAgB;YACrBF,QAAQ,MAAM,CAAC,KAAK,CAAC;YAErB,MAAME;QACV;IACJ,OAAO;QACHF,QAAQ,MAAM,CAAC,WAAW,CAAC;IAC/B;AACJ"}
+{"version":3,"file":"honeycomb/initializeHoneycomb.js","sources":["webpack://@squide/firefly/./src/honeycomb/initializeHoneycomb.ts"],"sourcesContent":["import type { HoneycombInstrumentationPartialClient } from \"@workleap-telemetry/core\";\nimport type { FireflyRuntime } from \"../FireflyRuntime.tsx\";\n\nexport async function initializeHoneycomb(runtime: FireflyRuntime, honeycombInstrumentationClient?: HoneycombInstrumentationPartialClient) {\n    if (honeycombInstrumentationClient) {\n        try {\n            // Dynamically import the Honeycomb instrumentation to prevent loading all the Honeycomb libraries\n            // if Honeycomb instrumentation is not registered by the hosting application.\n            const mod = await import(\"./registerHoneycombInstrumentation.ts\");\n\n            mod.registerHoneycombInstrumentation(runtime, honeycombInstrumentationClient);\n        } catch (error: unknown) {\n            runtime.logger.error(\"[squide] Failed to register Honeycomb instrumentation. The \\\"./registerHoneycombInstrumentation.ts\\\" file cannot be imported.\");\n\n            throw error;\n        }\n    } else {\n        runtime.logger.information(\"[squide] Cannot register Honeycomb instrumentation because the host application hasn't provided a client.\");\n    }\n}\n\n\n"],"names":["initializeHoneycomb","runtime","honeycombInstrumentationClient","mod","error"],"mappings":";;AAGO,eAAeA,oBAAoBC,OAAuB,EAAEC,8BAAsE;IACrI,IAAIA,gCAAgC;QAChC,IAAI;YACA,kGAAkG;YAClG,6EAA6E;YAC7E,MAAMC,MAAM,MAAM,+CAA+C;YAEjEA,IAAI,gCAAgC,CAACF,SAASC;QAClD,EAAE,OAAOE,OAAgB;YACrBH,QAAQ,MAAM,CAAC,KAAK,CAAC;YAErB,MAAMG;QACV;IACJ,OAAO;QACHH,QAAQ,MAAM,CAAC,WAAW,CAAC;IAC/B;AACJ"}

package/dist/honeycomb/registerHoneycombInstrumentation.d.ts

@@ -1,3 +1,4 @@
+import type { HoneycombInstrumentationPartialClient } from "@workleap-telemetry/core";
 import type { FireflyRuntime } from "../FireflyRuntime.tsx";
-export declare function reduceDataFetchEvents(runtime: FireflyRuntime, onDataFetchStarted: () => void, onDataReady: () => void, onPublicDataFetchStarted: () => void, onPublicDataReady: () => void, onProtectedDataFetchStarted: () => void, onProtectedDataReady: () => void, onDataFetchFailed: (queriesErrors: Error[]) => void): void;
-export declare function registerHoneycombInstrumentation(runtime: FireflyRuntime): void;
+export declare function reduceDataFetchEvents(runtime: FireflyRuntime, onDataFetchStarted: () => void, onDataReady: () => void, onPublicDataFetchStarted: () => void, onPublicDataReady: () => void, onProtectedDataFetchStarted: () => void, onProtectedDataReady: () => void, onDataFetchFailed: (queriesErrors: Error[]) => void, onUnmanagedError: (error: unknown) => void): void;
+export declare function registerHoneycombInstrumentation(runtime: FireflyRuntime, honeycombInstrumentationClient: HoneycombInstrumentationPartialClient): void;

package/dist/honeycomb/registerHoneycombInstrumentation.js

@@ -36,18 +36,29 @@ import { endActiveSpan, startActiveChildSpan, startChildSpan, startSpan, traceEr
 
 
 
-function reduceDataFetchEvents(runtime, onDataFetchStarted, onDataReady, onPublicDataFetchStarted, onPublicDataReady, onProtectedDataFetchStarted, onProtectedDataReady, onDataFetchFailed) {
+function addProtectedListener(runtime, eventName, callback, options) {
+    const protectedCallback = (...args)=>{
+        try {
+            callback(...args);
+        } catch (error) {
+            runtime.logger.withText(`[squide] An unmanaged error occurred while handling event "${eventName.toString()}" for Honeycomb instrumentation:`).withError(error).error();
+        }
+    };
+    runtime.eventBus.addListener(eventName, protectedCallback, options);
+}
+function reduceDataFetchEvents(runtime, onDataFetchStarted, onDataReady, onPublicDataFetchStarted, onPublicDataReady, onProtectedDataFetchStarted, onProtectedDataReady, onDataFetchFailed, onUnmanagedError) {
     let dataFetchState = "none";
-    runtime.eventBus.addListener(PublicDataFetchStartedEvent, ()=>{
+    addProtectedListener(runtime, PublicDataFetchStartedEvent, ()=>{
         if (dataFetchState === "none") {
             dataFetchState = "fetching-data";
             onDataFetchStarted();
         }
         onPublicDataFetchStarted();
     }, {
-        once: true
+        once: true,
+        onError: onUnmanagedError
     });
-    runtime.eventBus.addListener(PublicDataReadyEvent, (payload)=>{
+    addProtectedListener(runtime, PublicDataReadyEvent, (payload)=>{
         onPublicDataReady();
         if (dataFetchState === "fetching-data") {
             if (payload && !payload.waitForProtectedData) {
@@ -61,18 +72,20 @@ function reduceDataFetchEvents(runtime, onDataFetchStarted, onDataReady, onPubli
             onDataReady();
         }
     }, {
-        once: true
+        once: true,
+        onError: onUnmanagedError
     });
-    runtime.eventBus.addListener(ProtectedDataFetchStartedEvent, ()=>{
+    addProtectedListener(runtime, ProtectedDataFetchStartedEvent, ()=>{
         if (dataFetchState === "none") {
             dataFetchState = "fetching-data";
             onDataFetchStarted();
         }
         onProtectedDataFetchStarted();
     }, {
-        once: true
+        once: true,
+        onError: onUnmanagedError
     });
-    runtime.eventBus.addListener(ProtectedDataReadyEvent, (payload)=>{
+    addProtectedListener(runtime, ProtectedDataReadyEvent, (payload)=>{
         onProtectedDataReady();
         if (dataFetchState === "fetching-data") {
             if (payload && !payload.waitForPublicData) {
@@ -86,7 +99,8 @@ function reduceDataFetchEvents(runtime, onDataFetchStarted, onDataReady, onPubli
             onDataReady();
         }
     }, {
-        once: true
+        once: true,
+        onError: onUnmanagedError
     });
     const handleDataFetchFailed = (payload)=>{
         if (dataFetchState !== "data-fetch-failed") {
@@ -94,15 +108,18 @@ function reduceDataFetchEvents(runtime, onDataFetchStarted, onDataReady, onPubli
             onDataFetchFailed(payload);
         }
     };
-    runtime.eventBus.addListener(PublicDataFetchFailedEvent, handleDataFetchFailed, {
-        once: true
+    addProtectedListener(runtime, PublicDataFetchFailedEvent, handleDataFetchFailed, {
+        once: true,
+        onError: onUnmanagedError
     });
-    runtime.eventBus.addListener(ProtectedDataFetchFailedEvent, handleDataFetchFailed, {
-        once: true
+    addProtectedListener(runtime, ProtectedDataFetchFailedEvent, handleDataFetchFailed, {
+        once: true,
+        onError: onUnmanagedError
     });
 }
 function registerTrackingListeners(runtime) {
     let bootstrappingSpan;
+    let bootstrappingSpanHasEnded = false;
     let localModuleRegistrationSpan;
     let localModuleDeferredRegistrationSpan;
     let remoteModuleRegistrationSpan;
@@ -111,26 +128,61 @@ function registerTrackingListeners(runtime) {
     let deferredRegistrationsUpdateSpan;
     let localModuleDeferredRegistrationsUpdateSpan;
     let remoteModuleDeferredRegistrationsUpdateSpan;
-    runtime.eventBus.addListener(ApplicationBootstrappingStartedEvent, ()=>{
+    const handleUnmanagedError = (error)=>{
+        if (bootstrappingSpan && !bootstrappingSpanHasEnded) {
+            traceError(bootstrappingSpan, error);
+            bootstrappingSpan.end();
+            bootstrappingSpanHasEnded = true;
+        }
+        if (localModuleRegistrationSpan) {
+            localModuleRegistrationSpan.end();
+        }
+        if (localModuleDeferredRegistrationSpan) {
+            localModuleDeferredRegistrationSpan.end();
+        }
+        if (remoteModuleRegistrationSpan) {
+            remoteModuleRegistrationSpan.end();
+        }
+        if (remoteModuleDeferredRegistrationSpan) {
+            remoteModuleDeferredRegistrationSpan.end();
+        }
+        if (dataFetchSpan) {
+            dataFetchSpan.instance.end();
+        }
+        if (deferredRegistrationsUpdateSpan) {
+            deferredRegistrationsUpdateSpan.end();
+        }
+        if (localModuleDeferredRegistrationsUpdateSpan) {
+            localModuleDeferredRegistrationsUpdateSpan.instance.end();
+        }
+        if (remoteModuleDeferredRegistrationsUpdateSpan) {
+            remoteModuleDeferredRegistrationsUpdateSpan.instance.end();
+        }
+    };
+    addProtectedListener(runtime, ApplicationBootstrappingStartedEvent, ()=>{
         bootstrappingSpan = startSpan((options, context)=>getTracer().startSpan("squide-bootstrapping", options, context));
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(ApplicationBoostrappedEvent, ()=>{
+    addProtectedListener(runtime, ApplicationBoostrappedEvent, ()=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.end();
+            bootstrappingSpanHasEnded = true;
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(MswReadyEvent, ()=>{
+    addProtectedListener(runtime, MswReadyEvent, ()=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.addEvent("msw-ready");
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(LocalModulesRegistrationStartedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModulesRegistrationStartedEvent, (payload)=>{
         const attributes = {
             "app.squide.module_count": payload.moduleCount
         };
@@ -144,9 +196,10 @@ function registerTrackingListeners(runtime) {
             }, context);
         });
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(LocalModulesRegistrationCompletedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModulesRegistrationCompletedEvent, (payload)=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.addEvent("local-module-registration-completed", {
                 "app.squide.module_count": payload.moduleCount
@@ -156,16 +209,19 @@ function registerTrackingListeners(runtime) {
             localModuleRegistrationSpan.end();
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(LocalModuleRegistrationFailedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModuleRegistrationFailedEvent, (payload)=>{
         const registrationError = payload;
         if (localModuleRegistrationSpan) {
             traceError(localModuleRegistrationSpan, registrationError);
         }
+    }, {
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(LocalModulesDeferredRegistrationStartedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModulesDeferredRegistrationStartedEvent, (payload)=>{
         const attributes = {
             "app.squide.registration_count": payload.registrationCount
         };
@@ -179,9 +235,10 @@ function registerTrackingListeners(runtime) {
             }, context);
         });
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(LocalModulesDeferredRegistrationCompletedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModulesDeferredRegistrationCompletedEvent, (payload)=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.addEvent("local-module-deferred-registration-completed", {
                 "app.squide.registration_count": payload.registrationCount
@@ -191,16 +248,19 @@ function registerTrackingListeners(runtime) {
             localModuleDeferredRegistrationSpan.end();
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(LocalModuleDeferredRegistrationFailedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModuleDeferredRegistrationFailedEvent, (payload)=>{
         const registrationError = payload;
         if (localModuleDeferredRegistrationSpan) {
             traceError(localModuleRegistrationSpan, registrationError);
         }
+    }, {
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(RemoteModulesRegistrationStartedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModulesRegistrationStartedEvent, (payload)=>{
         const attributes = {
             "app.squide.remote_count": payload.remoteCount
         };
@@ -214,9 +274,10 @@ function registerTrackingListeners(runtime) {
             }, context);
         });
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(RemoteModulesRegistrationCompletedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModulesRegistrationCompletedEvent, (payload)=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.addEvent("remote-module-registration-completed", {
                 "app.squide.remote_count": payload.remoteCount
@@ -226,16 +287,19 @@ function registerTrackingListeners(runtime) {
             remoteModuleRegistrationSpan.end();
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(RemoteModuleRegistrationFailedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModuleRegistrationFailedEvent, (payload)=>{
         const registrationError = payload;
         if (remoteModuleRegistrationSpan) {
             traceError(remoteModuleRegistrationSpan, registrationError);
         }
+    }, {
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(RemoteModulesDeferredRegistrationStartedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModulesDeferredRegistrationStartedEvent, (payload)=>{
         const attributes = {
             "app.squide.registration_count": payload.registrationCount
         };
@@ -249,9 +313,10 @@ function registerTrackingListeners(runtime) {
             }, context);
         });
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(RemoteModulesDeferredRegistrationCompletedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModulesDeferredRegistrationCompletedEvent, (payload)=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.addEvent("remote-module-deferred-registration-completed", {
                 "app.squide.registration_count": payload.registrationCount
@@ -261,14 +326,17 @@ function registerTrackingListeners(runtime) {
             remoteModuleDeferredRegistrationSpan.end();
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(RemoteModuleDeferredRegistrationFailedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModuleDeferredRegistrationFailedEvent, (payload)=>{
         const registrationError = payload;
         if (remoteModuleDeferredRegistrationSpan) {
             traceError(remoteModuleDeferredRegistrationSpan, registrationError);
         }
+    }, {
+        onError: handleUnmanagedError
     });
     const handleFetchDataStarted = ()=>{
         dataFetchSpan = startActiveChildSpan(bootstrappingSpan, (options, context)=>{
@@ -315,36 +383,43 @@ function registerTrackingListeners(runtime) {
             // will be aborted and a react-router error boundary will be rendered.
             if (bootstrappingSpan) {
                 bootstrappingSpan.end();
+                bootstrappingSpanHasEnded = true;
             }
         }
     };
-    reduceDataFetchEvents(runtime, handleFetchDataStarted, handleDataReady, handlePublicDataFetchStarted, handlePublicDataReady, handleProtectedDataFetchStarted, handleProtectedDataReady, handleDataFetchFailed);
-    runtime.eventBus.addListener(ModulesRegisteredEvent, ()=>{
+    reduceDataFetchEvents(runtime, handleFetchDataStarted, handleDataReady, handlePublicDataFetchStarted, handlePublicDataReady, handleProtectedDataFetchStarted, handleProtectedDataReady, handleDataFetchFailed, handleUnmanagedError);
+    addProtectedListener(runtime, ModulesRegisteredEvent, ()=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.addEvent("modules-registered");
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
-    runtime.eventBus.addListener(ModulesReadyEvent, ()=>{
+    addProtectedListener(runtime, ModulesReadyEvent, ()=>{
         if (bootstrappingSpan) {
             bootstrappingSpan.addEvent("modules-ready");
         }
     }, {
-        once: true
+        once: true,
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(DeferredRegistrationsUpdateStartedEvent, ()=>{
+    addProtectedListener(runtime, DeferredRegistrationsUpdateStartedEvent, ()=>{
         deferredRegistrationsUpdateSpan = startSpan((options, context)=>getTracer().startSpan("squide-deferred-registrations-update", options, context));
+    }, {
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(DeferredRegistrationsUpdateCompletedEvent, ()=>{
+    addProtectedListener(runtime, DeferredRegistrationsUpdateCompletedEvent, ()=>{
         if (deferredRegistrationsUpdateSpan) {
             deferredRegistrationsUpdateSpan.end();
         }
+    }, {
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(LocalModulesDeferredRegistrationsUpdateStartedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModulesDeferredRegistrationsUpdateStartedEvent, (payload)=>{
         const attributes = {
             "app.squide.registration_count": payload.registrationCount
         };
@@ -362,9 +437,11 @@ function registerTrackingListeners(runtime) {
                 span
             };
         });
+    }, {
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(LocalModulesDeferredRegistrationsUpdateCompletedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModulesDeferredRegistrationsUpdateCompletedEvent, (payload)=>{
         if (deferredRegistrationsUpdateSpan) {
             deferredRegistrationsUpdateSpan.addEvent("local-module-deferred-registrations-update-completed", {
                 "app.squide.registration_count": payload.registrationCount
@@ -373,16 +450,20 @@ function registerTrackingListeners(runtime) {
         if (localModuleDeferredRegistrationsUpdateSpan) {
             endActiveSpan(localModuleDeferredRegistrationsUpdateSpan);
         }
+    }, {
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(LocalModuleDeferredRegistrationUpdateFailedEvent, (payload)=>{
+    addProtectedListener(runtime, LocalModuleDeferredRegistrationUpdateFailedEvent, (payload)=>{
         const registrationError = payload;
         if (localModuleDeferredRegistrationsUpdateSpan) {
             traceError(localModuleDeferredRegistrationsUpdateSpan.instance, registrationError);
         }
+    }, {
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(RemoteModulesDeferredRegistrationsUpdateStartedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModulesDeferredRegistrationsUpdateStartedEvent, (payload)=>{
         const attributes = {
             "app.squide.registration_count": payload.registrationCount
         };
@@ -400,9 +481,11 @@ function registerTrackingListeners(runtime) {
                 span
             };
         });
+    }, {
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(RemoteModulesDeferredRegistrationsUpdateCompletedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModulesDeferredRegistrationsUpdateCompletedEvent, (payload)=>{
         if (deferredRegistrationsUpdateSpan) {
             deferredRegistrationsUpdateSpan.addEvent("remote-module-deferred-registrations-update-completed", {
                 "app.squide.registration_count": payload.registrationCount
@@ -411,40 +494,30 @@ function registerTrackingListeners(runtime) {
         if (remoteModuleDeferredRegistrationsUpdateSpan) {
             endActiveSpan(remoteModuleDeferredRegistrationsUpdateSpan);
         }
+    }, {
+        onError: handleUnmanagedError
     });
     // Can occur multiple times.
-    runtime.eventBus.addListener(RemoteModuleDeferredRegistrationUpdateFailedEvent, (payload)=>{
+    addProtectedListener(runtime, RemoteModuleDeferredRegistrationUpdateFailedEvent, (payload)=>{
         const registrationError = payload;
         if (remoteModuleDeferredRegistrationsUpdateSpan) {
             traceError(remoteModuleDeferredRegistrationsUpdateSpan.instance, registrationError);
         }
+    }, {
+        onError: handleUnmanagedError
     });
 }
-function getRegisterFetchRequestHookFunction() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    if (globalThis.__WLP_HONEYCOMB_REGISTER_DYNAMIC_FETCH_REQUEST_HOOK__) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return globalThis.__WLP_HONEYCOMB_REGISTER_DYNAMIC_FETCH_REQUEST_HOOK__;
-    }
-    // Fallback to fix an error. Will remove soon.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    return globalThis.__WLP_HONEYCOMB_REGISTER_DYNAMIC_FETCH_REQUEST_HOOK;
-}
-function registerHoneycombInstrumentation(runtime) {
-    const registerFetchRequestHookFunction = getRegisterFetchRequestHookFunction();
-    if (registerFetchRequestHookFunction) {
+function registerHoneycombInstrumentation(runtime, honeycombInstrumentationClient) {
+    try {
         registerActiveSpanStack();
-        const activeSpanOverrideFunction = createOverrideFetchRequestSpanWithActiveSpanContext(runtime.logger);
         // Dynamically registering this request hook function to nest the HTTP requests
         // of squide bootstrapping under the appropriate Honeycomb span.
-        registerFetchRequestHookFunction(activeSpanOverrideFunction);
-    } else {
-        runtime.logger.warning("[squide] Cannot register Honeycomb fetch request hook because \"globalThis.__WLP_HONEYCOMB_REGISTER_DYNAMIC_FETCH_REQUEST_HOOK__\" is not available. Honeycomb instrumentation is still functional but in degraded mode.");
+        honeycombInstrumentationClient.registerFetchRequestHook(createOverrideFetchRequestSpanWithActiveSpanContext(runtime.logger));
+        registerTrackingListeners(runtime);
+        runtime.logger.information("[squide] Honeycomb instrumentation is registered.");
+    } catch (error) {
+        runtime.logger.withText("[squide] An error occurred while registering Honeycomb instrumentation:").withError(error).error();
     }
-    registerTrackingListeners(runtime);
 }
 
 export { reduceDataFetchEvents, registerHoneycombInstrumentation };