@squide/firefly 13.0.0 → 13.0.2

package/src/honeycomb/registerHoneycombInstrumentation.ts

@@ -40,8 +40,8 @@ import {
 import { ApplicationBoostrappedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, PublicDataReadyEvent } from "../AppRouterReducer.ts";
 import type { FireflyRuntime } from "../FireflyRuntime.tsx";
 import { ApplicationBootstrappingStartedEvent } from "../initializeFirefly.ts";
-import { ProtectedDataFetchStartedEvent } from "../useProtectedDataQueries.ts";
-import { PublicDataFetchStartedEvent } from "../usePublicDataQueries.ts";
+import { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent } from "../useProtectedDataQueries.ts";
+import { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent } from "../usePublicDataQueries.ts";
 import { type ActiveSpan, createOverrideFetchRequestSpanWithActiveSpanContext, registerActiveSpanStack } from "./activeSpan.ts";
 import { getTracer } from "./tracer.ts";
 import { endActiveSpan, startActiveChildSpan, startChildSpan, startSpan, traceError } from "./utils.ts";
@@ -49,30 +49,29 @@ import { endActiveSpan, startActiveChildSpan, startChildSpan, startSpan, traceEr
 // TIPS:
 // To query those traces in Honeycomb, use the following query filter: "root.name = squide-bootstrapping".
 
-type DataFetchState = "none" | "fetching-data" | "public-data-ready" | "protected-data-ready" | "data-ready";
+type DataFetchState = "none" | "fetching-data" | "public-data-ready" | "protected-data-ready" | "data-ready" | "data-fetch-failed";
 
 export function reduceDataFetchEvents(
     runtime: FireflyRuntime,
-    onDataFetchingStarted: () => void,
+    onDataFetchStarted: () => void,
     onDataReady: () => void,
     onPublicDataFetchStarted: () => void,
     onPublicDataReady: () => void,
     onProtectedDataFetchStarted: () => void,
-    onProtectedDataReady: () => void
+    onProtectedDataReady: () => void,
+    onDataFetchFailed: (queriesErrors: Error[]) => void
 ) {
     let dataFetchState: DataFetchState = "none";
 
-    // TODO: Validate if this handler should use { once: true }.
     runtime.eventBus.addListener(PublicDataFetchStartedEvent, () => {
         if (dataFetchState === "none") {
             dataFetchState = "fetching-data";
-            onDataFetchingStarted();
+            onDataFetchStarted();
         }
 
         onPublicDataFetchStarted();
-    });
+    }, { once: true });
 
-    // TODO: Validate if this handler should use { once: true }.
     runtime.eventBus.addListener(PublicDataReadyEvent, () => {
         onPublicDataReady();
 
@@ -82,19 +81,17 @@ export function reduceDataFetchEvents(
             dataFetchState = "data-ready";
             onDataReady();
         }
-    });
+    }, { once: true });
 
-    // TODO: Validate if this handler should use { once: true }.
     runtime.eventBus.addListener(ProtectedDataFetchStartedEvent, () => {
         if (dataFetchState === "none") {
             dataFetchState = "fetching-data";
-            onDataFetchingStarted();
+            onDataFetchStarted();
         }
 
         onProtectedDataFetchStarted();
-    });
+    }, { once: true });
 
-    // TODO: Validate if this handler should use { once: true }.
     runtime.eventBus.addListener(ProtectedDataReadyEvent, () => {
         onProtectedDataReady();
 
@@ -104,7 +101,18 @@ export function reduceDataFetchEvents(
             dataFetchState = "data-ready";
             onDataReady();
         }
-    });
+    }, { once: true });
+
+    const handleDataFetchFailed = (payload: unknown) => {
+        if (dataFetchState !== "data-fetch-failed") {
+            dataFetchState = "data-fetch-failed";
+
+            onDataFetchFailed(payload as Error[]);
+        }
+    };
+
+    runtime.eventBus.addListener(PublicDataFetchFailedEvent, handleDataFetchFailed, { once: true });
+    runtime.eventBus.addListener(ProtectedDataFetchFailedEvent, handleDataFetchFailed, { once: true });
 }
 
 function registerTrackingListeners(runtime: FireflyRuntime) {
@@ -316,6 +324,24 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
         }
     };
 
+    const handleDataFetchFailed = (queriesErrors: Error[]) => {
+        if (dataFetchSpan) {
+            queriesErrors.forEach(x => {
+                traceError(dataFetchSpan.instance, x);
+            });
+
+            dataFetchSpan.instance.end();
+        }
+
+        if (bootstrappingSpan) {
+            queriesErrors.forEach(x => {
+                traceError(bootstrappingSpan, x);
+            });
+
+            bootstrappingSpan.end();
+        }
+    };
+
     reduceDataFetchEvents(
         runtime,
         handleFetchDataStarted,
@@ -323,7 +349,8 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
         handlePublicDataFetchStarted,
         handlePublicDataReady,
         handleProtectedDataFetchStarted,
-        handleProtectedDataReady
+        handleProtectedDataReady,
+        handleDataFetchFailed
     );
 
     runtime.eventBus.addListener(ModulesRegisteredEvent, () => {
@@ -467,38 +494,4 @@ export function registerHoneycombInstrumentation(runtime: FireflyRuntime) {
     }
 
     registerTrackingListeners(runtime);
-
-    // try {
-    //     const registerFetchRequestHookFunction = getRegisterFetchRequestHookFunction();
-
-    //     if (registerFetchRequestHookFunction) {
-    //         const overrideFetchRequestHook = createOverrideFetchRequestWithManifestSectionSpanContext(runtime.logger);
-
-    //         // Dynamically registering this request hook function to nest the HTTP requests
-    //         // of the widgets initialization under the appropriate Honeycomb span.
-    //         registerFetchRequestHookFunction(overrideFetchRequestHook);
-    //     } else {
-    //         runtime.logger.warning("[wlp-widgets] 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.");
-    //     }
-
-    //     registerTrackingListeners(runtime);
-    // } catch (error: unknown) {
-    //     runtime.logger.error("[wlp-widgets] An error occured while registering Honeycomb instrumentation.", error);
-    //     runtime.errorPropagator.propagate(error as Error);
-    // }
 }
-
-export function canRegisterHoneycombInstrumentation() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    return globalThis.__WLP_HONEYCOMB_INSTRUMENTATION_IS_REGISTERED__ === true;
-}
-
-// export function registerHoneycombInstrumentation(runtime: FireflyRuntime, namespace: string, serviceName: NonNullable<HoneycombSdkOptions["serviceName"]>, apiServiceUrls: PropagateTraceHeaderCorsUrls, options?: RegisterHoneycombInstrumentationOptions) {
-//     const augmentedOptions = getInstrumentationOptions(runtime, options);
-
-//     registerWorkleapHoneycombInstrumentation(namespace, serviceName, apiServiceUrls, augmentedOptions);
-
-//     registerTrackingListeners(runtime);
-//     registerActiveSpanStack();
-// }

package/src/initializeFirefly.ts

@@ -2,7 +2,7 @@ import { isFunction, registerLocalModules, type ModuleRegisterFunction, type Reg
 import { registerRemoteModules, type RemoteDefinition } from "@squide/module-federation";
 import { setMswAsReady } from "@squide/msw";
 import { FireflyRuntime, type FireflyRuntimeOptions } from "./FireflyRuntime.tsx";
-import { canRegisterHoneycombInstrumentation, registerHoneycombInstrumentation } from "./honeycomb/registerHoneycombInstrumentation.ts";
+import { initializeHoneycomb } from "./honeycomb/initializeHoneycomb.ts";
 
 export const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
 
@@ -70,7 +70,8 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
         mode,
         useMsw,
         loggers,
-        plugins
+        plugins,
+        onError
     } = options;
 
     if (hasExecuted) {
@@ -86,13 +87,15 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
         plugins
     });
 
-    if (canRegisterHoneycombInstrumentation()) {
-        registerHoneycombInstrumentation(runtime);
-    } else {
-        runtime.logger.debug("[squide] Cannot register Honeycomb instrumentation because the host application is not using the \"@workleap/honeycomb\" package.");
-    }
-
-    bootstrap(runtime, options);
+    initializeHoneycomb(runtime)
+        .catch((error: unknown) => {
+            if (onError) {
+                onError(error);
+            }
+        })
+        .finally(() => {
+            bootstrap(runtime, options);
+        });
 
     return runtime;
 }