@reservamos/browser-analytics 1.1.7-alpha.1 → 1.1.8-alpha.0

package/src/track.ts

@@ -89,12 +89,42 @@ export function trackEventError(
   });
 }
 
-export async function tryTrackEvent(trackEventCallback: () => Promise<void>) {
-  if (mixpanelService.isReady()) {
+/** Waits for one bounded attempt, then consumes callback failures. */
+export async function tryTrackEvent(
+  trackEventCallback: () => Promise<void>,
+  eventName = 'Track Event Error',
+): Promise<void> {
+  if (!mixpanelService.isReady()) {
+    const ready = await new Promise<boolean>((resolve) => {
+      const finish = (isReady: boolean) => {
+        clearTimeout(timer);
+        window.removeEventListener('Tracker Ready', onReady);
+        resolve(isReady);
+      };
+      const onReady = () => {
+        if (mixpanelService.isReady()) finish(true);
+      };
+      const timer = setTimeout(() => finish(mixpanelService.isReady()), 5000);
+      window.addEventListener('Tracker Ready', onReady);
+      onReady();
+    });
+    if (!ready) {
+      console.error('Tracking diagnostic', {
+        eventName,
+        stage: 'readiness',
+        reason: 'timeout',
+      });
+      return;
+    }
+  }
+
+  try {
     await trackEventCallback();
-  } else {
-    window.addEventListener('Tracker Ready', async () => {
-      await trackEventCallback();
+  } catch {
+    console.error('Tracking diagnostic', {
+      eventName,
+      stage: 'submission',
+      reason: 'failed',
     });
   }
 }
@@ -105,33 +135,50 @@ export async function tryTrackEvent(trackEventCallback: () => Promise<void>) {
  * @param {string} eventName - The name of the event to track.
  * @param {object} eventProperties - The properties of the event to track.
  * @param {EventMetadata} meta - Additional metadata to include in the event.
- * @throws {Error} Throws an error if Mixpanel or Fingerprint is not ready.
+ * Waits up to five seconds for Mixpanel readiness before event submission.
+ * Optional fingerprint failure does not discard an otherwise valid event.
  */
-export async function trackEvent(
+export function trackEvent(
   eventName: string,
   eventProperties: object,
   meta: EventMetadata = {},
 ): Promise<void> {
-  if (!mixpanelService.isReady()) {
-    throw new Error('Mixpanel is not initialized.');
-  }
+  return tryTrackEvent(
+    () => submitEvent(eventName, eventProperties, meta),
+    eventName,
+  );
+}
 
+async function submitEvent(
+  eventName: string,
+  eventProperties: object,
+  meta: EventMetadata,
+): Promise<void> {
   try {
     validator.parseEventProps(eventName, eventProperties);
     // Call the Mixpanel service to store the distinct ID in the cache
     const distinctId = mixpanelService.getMixpanelDistinctId();
     const botDetectionEnabled =
       botDetectionRelayService.isEnabledFor(eventName);
-    let fingerprint: string;
-    let fingerprintRequestId: string | undefined;
+    let fingerprint = '';
 
-    if (botDetectionEnabled && fingerprintService.isFingerprintReady()) {
-      const identification = await fingerprintService.identifyVisitor(true);
-      fingerprint = identification.visitorId;
-      fingerprintRequestId = identification.requestId;
+    if (botDetectionEnabled) {
+      try {
+        fingerprint = fingerprintService.getCachedFingerprint() ?? '';
+      } catch (error) {
+        console.error('Error reading cached fingerprint:', error);
+      }
     } else {
       const cacheOnly = !FP_TRIGGER_EVENTS.includes(eventName);
-      fingerprint = await fingerprintService.getFingerprint(cacheOnly);
+      try {
+        fingerprint = await fingerprintService.getFingerprint(cacheOnly);
+      } catch {
+        console.error('Tracking diagnostic', {
+          eventName,
+          stage: 'fingerprint',
+          reason: 'failed',
+        });
+      }
     }
     const defaultCoordinates: Record<string, string | number> = {};
     const coordinates = geolocationService.getCoordinates();
@@ -159,13 +206,8 @@ export async function trackEvent(
 
     mixpanelService.track(eventName, properties);
 
-    if (fingerprintRequestId) {
-      void botDetectionRelayService.relay({
-        requestId: fingerprintRequestId,
-        visitorId: fingerprint,
-        ...(distinctId && { distinctId }),
-        eventName,
-      });
+    if (botDetectionEnabled) {
+      void identifyAndRelayFingerprint(eventName, distinctId);
     }
   } catch (error) {
     console.error(`Error tracking event '${eventName}':`, error);
@@ -173,6 +215,28 @@ export async function trackEvent(
   }
 }
 
+/** Identifies and relays only after the original event has been submitted. */
+async function identifyAndRelayFingerprint(
+  eventName: string,
+  distinctId: string | null,
+): Promise<void> {
+  try {
+    if (!fingerprintService.isFingerprintReady()) return;
+
+    const identification = await fingerprintService.identifyVisitor(true);
+    if (!identification.requestId) return;
+
+    await botDetectionRelayService.relay({
+      requestId: identification.requestId,
+      visitorId: identification.visitorId,
+      ...(distinctId && { distinctId }),
+      eventName,
+    });
+  } catch (error) {
+    console.error(`Error running Bot Detection for '${eventName}':`, error);
+  }
+}
+
 /**
  * Extracts UTM and other tracking parameters from the current URL that match predefined fields.
  * @returns {Record<string, string>} An object containing matched tracking parameters.