@firebase/performance 0.7.6 → 0.7.7-canary.2b5731292

package/dist/esm/index.esm2017.js

@@ -6,7 +6,7 @@ import { Component } from '@firebase/component';
 import '@firebase/installations';
 
 const name = "@firebase/performance";
-const version = "0.7.6";
+const version = "0.7.7-canary.2b5731292";
 
 /**
  * @license
@@ -327,6 +327,9 @@ class SettingsService {
         this.logNetworkAfterSampling = false;
         // TTL of config retrieved from remote config in hours.
         this.configTimeToLive = 12;
+        // The max number of events to send during a flush. This number is kept low to since Chrome has a
+        // shared payload limit for all sendBeacon calls in the same nav context.
+        this.logMaxFlushSize = 40;
     }
     getFlTransportFullUrl() {
         return this.flTransportEndpointUrl.concat('?key=', this.transportKey);
@@ -614,6 +617,12 @@ function processConfig(config) {
         settingsServiceInstance.tracesSamplingRate =
             DEFAULT_CONFIGS.tracesSamplingRate;
     }
+    if (entries.fpr_log_max_flush_size) {
+        settingsServiceInstance.logMaxFlushSize = Number(entries.fpr_log_max_flush_size);
+    }
+    else if (DEFAULT_CONFIGS.logMaxFlushSize) {
+        settingsServiceInstance.logMaxFlushSize = DEFAULT_CONFIGS.logMaxFlushSize;
+    }
     // Set the per session trace and network logging flags.
     settingsServiceInstance.logTraceAfterSampling = shouldLogAfterSampling(settingsServiceInstance.tracesSamplingRate);
     settingsServiceInstance.logNetworkAfterSampling = shouldLogAfterSampling(settingsServiceInstance.networkRequestsSamplingRate);
@@ -704,6 +713,9 @@ const DEFAULT_SEND_INTERVAL_MS = 10 * 1000;
 const INITIAL_SEND_TIME_DELAY_MS = 5.5 * 1000;
 const MAX_EVENT_COUNT_PER_REQUEST = 1000;
 const DEFAULT_REMAINING_TRIES = 3;
+// Most browsers have a max payload of 64KB for sendbeacon/keep alive payload.
+const MAX_SEND_BEACON_PAYLOAD_SIZE = 65536;
+const TEXT_ENCODER = new TextEncoder();
 let remainingTries = DEFAULT_REMAINING_TRIES;
 /* eslint-enable camelcase */
 let queue = [];
@@ -731,13 +743,28 @@ function dispatchQueueEvents() {
     // The staged events will be used for current logRequest attempt, remaining events will be kept
     // for next attempt.
     const staged = queue.splice(0, MAX_EVENT_COUNT_PER_REQUEST);
+    const data = buildPayload(staged);
+    postToFlEndpoint(data)
+        .then(() => {
+        remainingTries = DEFAULT_REMAINING_TRIES;
+    })
+        .catch(() => {
+        // If the request fails for some reason, add the events that were attempted
+        // back to the primary queue to retry later.
+        queue = [...staged, ...queue];
+        remainingTries--;
+        consoleLogger.info(`Tries left: ${remainingTries}.`);
+        processQueue(DEFAULT_SEND_INTERVAL_MS);
+    });
+}
+function buildPayload(events) {
     /* eslint-disable camelcase */
     // We will pass the JSON serialized event to the backend.
-    const log_event = staged.map(evt => ({
+    const log_event = events.map(evt => ({
         source_extension_json_proto3: evt.message,
         event_time_ms: String(evt.eventTime)
     }));
-    const data = {
+    const transportBatchLog = {
         request_time_ms: String(Date.now()),
         client_info: {
             client_type: 1, // 1 is JS
@@ -747,29 +774,23 @@ function dispatchQueueEvents() {
         log_event
     };
     /* eslint-enable camelcase */
-    postToFlEndpoint(data)
-        .then(() => {
-        remainingTries = DEFAULT_REMAINING_TRIES;
-    })
-        .catch(() => {
-        // If the request fails for some reason, add the events that were attempted
-        // back to the primary queue to retry later.
-        queue = [...staged, ...queue];
-        remainingTries--;
-        consoleLogger.info(`Tries left: ${remainingTries}.`);
-        processQueue(DEFAULT_SEND_INTERVAL_MS);
-    });
+    return JSON.stringify(transportBatchLog);
 }
-function postToFlEndpoint(data) {
+/** Sends to Firelog. Atempts to use sendBeacon otherwsise uses fetch. */
+function postToFlEndpoint(body) {
     const flTransportFullUrl = SettingsService.getInstance().getFlTransportFullUrl();
-    const body = JSON.stringify(data);
-    return navigator.sendBeacon && navigator.sendBeacon(flTransportFullUrl, body)
-        ? Promise.resolve()
-        : fetch(flTransportFullUrl, {
+    const size = TEXT_ENCODER.encode(body).length;
+    if (size <= MAX_SEND_BEACON_PAYLOAD_SIZE &&
+        navigator.sendBeacon &&
+        navigator.sendBeacon(flTransportFullUrl, body)) {
+        return Promise.resolve();
+    }
+    else {
+        return fetch(flTransportFullUrl, {
             method: 'POST',
-            body,
-            keepalive: true
-        }).then();
+            body
+        });
+    }
 }
 function addToQueue(evt) {
     if (!evt.eventTime || !evt.message) {
@@ -791,12 +812,33 @@ serializer) {
     };
 }
 /**
- * Force flush the queued events. Useful at page unload time to ensure all
- * events are uploaded.
+ * Force flush the queued events. Useful at page unload time to ensure all events are uploaded.
+ * Flush will attempt to use sendBeacon to send events async and defaults back to fetch as soon as a
+ * sendBeacon fails. Firefox
  */
 function flushQueuedEvents() {
+    const flTransportFullUrl = SettingsService.getInstance().getFlTransportFullUrl();
     while (queue.length > 0) {
-        dispatchQueueEvents();
+        // Send the last events first to prioritize page load traces
+        const staged = queue.splice(-SettingsService.getInstance().logMaxFlushSize);
+        const body = buildPayload(staged);
+        if (navigator.sendBeacon &&
+            navigator.sendBeacon(flTransportFullUrl, body)) {
+            continue;
+        }
+        else {
+            queue = [...queue, ...staged];
+            break;
+        }
+    }
+    if (queue.length > 0) {
+        const body = buildPayload(queue);
+        fetch(flTransportFullUrl, {
+            method: 'POST',
+            body
+        }).catch(() => {
+            consoleLogger.info(`Failed flushing queued events.`);
+        });
     }
 }