1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, '__esModule', { value: true });
|
4 |
|
5 | var util = require('@firebase/util');
|
6 | var logger$1 = require('@firebase/logger');
|
7 | var tslib = require('tslib');
|
8 | var app = require('@firebase/app');
|
9 | var component = require('@firebase/component');
|
10 | require('@firebase/installations');
|
11 |
|
12 | var name = "@firebase/performance";
|
13 | var version = "0.6.6";
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 | var SDK_VERSION = version;
|
32 |
|
33 | var TRACE_START_MARK_PREFIX = 'FB-PERF-TRACE-START';
|
34 |
|
35 | var TRACE_STOP_MARK_PREFIX = 'FB-PERF-TRACE-STOP';
|
36 |
|
37 | var TRACE_MEASURE_PREFIX = 'FB-PERF-TRACE-MEASURE';
|
38 |
|
39 | var OOB_TRACE_PAGE_LOAD_PREFIX = '_wt_';
|
40 | var FIRST_PAINT_COUNTER_NAME = '_fp';
|
41 | var FIRST_CONTENTFUL_PAINT_COUNTER_NAME = '_fcp';
|
42 | var FIRST_INPUT_DELAY_COUNTER_NAME = '_fid';
|
43 | var CONFIG_LOCAL_STORAGE_KEY = '@firebase/performance/config';
|
44 | var CONFIG_EXPIRY_LOCAL_STORAGE_KEY = '@firebase/performance/configexpire';
|
45 | var SERVICE = 'performance';
|
46 | var SERVICE_NAME = 'Performance';
|
47 |
|
48 |
|
49 |
|
50 |
|
51 |
|
52 |
|
53 |
|
54 |
|
55 |
|
56 |
|
57 |
|
58 |
|
59 |
|
60 |
|
61 |
|
62 |
|
63 |
|
64 | var _a;
|
65 | var ERROR_DESCRIPTION_MAP = (_a = {},
|
66 | _a["trace started" ] = 'Trace {$traceName} was started before.',
|
67 | _a["trace stopped" ] = 'Trace {$traceName} is not running.',
|
68 | _a["nonpositive trace startTime" ] = 'Trace {$traceName} startTime should be positive.',
|
69 | _a["nonpositive trace duration" ] = 'Trace {$traceName} duration should be positive.',
|
70 | _a["no window" ] = 'Window is not available.',
|
71 | _a["no app id" ] = 'App id is not available.',
|
72 | _a["no project id" ] = 'Project id is not available.',
|
73 | _a["no api key" ] = 'Api key is not available.',
|
74 | _a["invalid cc log" ] = 'Attempted to queue invalid cc event',
|
75 | _a["FB not default" ] = 'Performance can only start when Firebase app instance is the default one.',
|
76 | _a["RC response not ok" ] = 'RC response is not ok',
|
77 | _a["invalid attribute name" ] = 'Attribute name {$attributeName} is invalid.',
|
78 | _a["invalid attribute value" ] = 'Attribute value {$attributeValue} is invalid.',
|
79 | _a["invalid custom metric name" ] = 'Custom metric name {$customMetricName} is invalid',
|
80 | _a["invalid String merger input" ] = 'Input for String merger is invalid, contact support team to resolve.',
|
81 | _a["already initialized" ] = 'initializePerformance() has already been called with ' +
|
82 | 'different options. To avoid this error, call initializePerformance() with the ' +
|
83 | 'same options as when it was originally called, or call getPerformance() to return the' +
|
84 | ' already initialized instance.',
|
85 | _a);
|
86 | var ERROR_FACTORY = new util.ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP);
|
87 |
|
88 |
|
89 |
|
90 |
|
91 |
|
92 |
|
93 |
|
94 |
|
95 |
|
96 |
|
97 |
|
98 |
|
99 |
|
100 |
|
101 |
|
102 |
|
103 |
|
104 | var consoleLogger = new logger$1.Logger(SERVICE_NAME);
|
105 | consoleLogger.logLevel = logger$1.LogLevel.INFO;
|
106 |
|
107 |
|
108 |
|
109 |
|
110 |
|
111 |
|
112 |
|
113 |
|
114 |
|
115 |
|
116 |
|
117 |
|
118 |
|
119 |
|
120 |
|
121 |
|
122 |
|
123 | var apiInstance;
|
124 | var windowInstance;
|
125 |
|
126 |
|
127 |
|
128 |
|
129 | var Api = (function () {
|
130 | function Api(window) {
|
131 | this.window = window;
|
132 | if (!window) {
|
133 | throw ERROR_FACTORY.create("no window" );
|
134 | }
|
135 | this.performance = window.performance;
|
136 | this.PerformanceObserver = window.PerformanceObserver;
|
137 | this.windowLocation = window.location;
|
138 | this.navigator = window.navigator;
|
139 | this.document = window.document;
|
140 | if (this.navigator && this.navigator.cookieEnabled) {
|
141 |
|
142 |
|
143 | this.localStorage = window.localStorage;
|
144 | }
|
145 | if (window.perfMetrics && window.perfMetrics.onFirstInputDelay) {
|
146 | this.onFirstInputDelay = window.perfMetrics.onFirstInputDelay;
|
147 | }
|
148 | }
|
149 | Api.prototype.getUrl = function () {
|
150 |
|
151 | return this.windowLocation.href.split('?')[0];
|
152 | };
|
153 | Api.prototype.mark = function (name) {
|
154 | if (!this.performance || !this.performance.mark) {
|
155 | return;
|
156 | }
|
157 | this.performance.mark(name);
|
158 | };
|
159 | Api.prototype.measure = function (measureName, mark1, mark2) {
|
160 | if (!this.performance || !this.performance.measure) {
|
161 | return;
|
162 | }
|
163 | this.performance.measure(measureName, mark1, mark2);
|
164 | };
|
165 | Api.prototype.getEntriesByType = function (type) {
|
166 | if (!this.performance || !this.performance.getEntriesByType) {
|
167 | return [];
|
168 | }
|
169 | return this.performance.getEntriesByType(type);
|
170 | };
|
171 | Api.prototype.getEntriesByName = function (name) {
|
172 | if (!this.performance || !this.performance.getEntriesByName) {
|
173 | return [];
|
174 | }
|
175 | return this.performance.getEntriesByName(name);
|
176 | };
|
177 | Api.prototype.getTimeOrigin = function () {
|
178 |
|
179 | return (this.performance &&
|
180 | (this.performance.timeOrigin || this.performance.timing.navigationStart));
|
181 | };
|
182 | Api.prototype.requiredApisAvailable = function () {
|
183 | if (!fetch || !Promise || !util.areCookiesEnabled()) {
|
184 | consoleLogger.info('Firebase Performance cannot start if browser does not support fetch and Promise or cookie is disabled.');
|
185 | return false;
|
186 | }
|
187 | if (!util.isIndexedDBAvailable()) {
|
188 | consoleLogger.info('IndexedDB is not supported by current browser');
|
189 | return false;
|
190 | }
|
191 | return true;
|
192 | };
|
193 | Api.prototype.setupObserver = function (entryType, callback) {
|
194 | if (!this.PerformanceObserver) {
|
195 | return;
|
196 | }
|
197 | var observer = new this.PerformanceObserver(function (list) {
|
198 | for (var _i = 0, _a = list.getEntries(); _i < _a.length; _i++) {
|
199 | var entry = _a[_i];
|
200 |
|
201 | callback(entry);
|
202 | }
|
203 | });
|
204 |
|
205 | observer.observe({ entryTypes: [entryType] });
|
206 | };
|
207 | Api.getInstance = function () {
|
208 | if (apiInstance === undefined) {
|
209 | apiInstance = new Api(windowInstance);
|
210 | }
|
211 | return apiInstance;
|
212 | };
|
213 | return Api;
|
214 | }());
|
215 | function setupApi(window) {
|
216 | windowInstance = window;
|
217 | }
|
218 |
|
219 |
|
220 |
|
221 |
|
222 |
|
223 |
|
224 |
|
225 |
|
226 |
|
227 |
|
228 |
|
229 |
|
230 |
|
231 |
|
232 |
|
233 |
|
234 |
|
235 | var iid;
|
236 | function getIidPromise(installationsService) {
|
237 | var iidPromise = installationsService.getId();
|
238 |
|
239 | iidPromise.then(function (iidVal) {
|
240 | iid = iidVal;
|
241 | });
|
242 | return iidPromise;
|
243 | }
|
244 |
|
245 | function getIid() {
|
246 | return iid;
|
247 | }
|
248 | function getAuthTokenPromise(installationsService) {
|
249 | var authTokenPromise = installationsService.getToken();
|
250 |
|
251 | authTokenPromise.then(function (authTokenVal) {
|
252 | });
|
253 | return authTokenPromise;
|
254 | }
|
255 |
|
256 |
|
257 |
|
258 |
|
259 |
|
260 |
|
261 |
|
262 |
|
263 |
|
264 |
|
265 |
|
266 |
|
267 |
|
268 |
|
269 |
|
270 |
|
271 |
|
272 | function mergeStrings(part1, part2) {
|
273 | var sizeDiff = part1.length - part2.length;
|
274 | if (sizeDiff < 0 || sizeDiff > 1) {
|
275 | throw ERROR_FACTORY.create("invalid String merger input" );
|
276 | }
|
277 | var resultArray = [];
|
278 | for (var i = 0; i < part1.length; i++) {
|
279 | resultArray.push(part1.charAt(i));
|
280 | if (part2.length > i) {
|
281 | resultArray.push(part2.charAt(i));
|
282 | }
|
283 | }
|
284 | return resultArray.join('');
|
285 | }
|
286 |
|
287 |
|
288 |
|
289 |
|
290 |
|
291 |
|
292 |
|
293 |
|
294 |
|
295 |
|
296 |
|
297 |
|
298 |
|
299 |
|
300 |
|
301 |
|
302 |
|
303 | var settingsServiceInstance;
|
304 | var SettingsService = (function () {
|
305 | function SettingsService() {
|
306 |
|
307 | this.instrumentationEnabled = true;
|
308 |
|
309 | this.dataCollectionEnabled = true;
|
310 |
|
311 | this.loggingEnabled = false;
|
312 |
|
313 | this.tracesSamplingRate = 1;
|
314 | this.networkRequestsSamplingRate = 1;
|
315 |
|
316 | this.logEndPointUrl = 'https://firebaselogging.googleapis.com/v0cc/log?format=json_proto';
|
317 |
|
318 |
|
319 | this.flTransportEndpointUrl = mergeStrings('hts/frbslgigp.ogepscmv/ieo/eaylg', 'tp:/ieaeogn-agolai.o/1frlglgc/o');
|
320 | this.transportKey = mergeStrings('AzSC8r6ReiGqFMyfvgow', 'Iayx0u-XT3vksVM-pIV');
|
321 |
|
322 | this.logSource = 462;
|
323 |
|
324 | this.logTraceAfterSampling = false;
|
325 | this.logNetworkAfterSampling = false;
|
326 |
|
327 | this.configTimeToLive = 12;
|
328 | }
|
329 | SettingsService.prototype.getFlTransportFullUrl = function () {
|
330 | return this.flTransportEndpointUrl.concat('?key=', this.transportKey);
|
331 | };
|
332 | SettingsService.getInstance = function () {
|
333 | if (settingsServiceInstance === undefined) {
|
334 | settingsServiceInstance = new SettingsService();
|
335 | }
|
336 | return settingsServiceInstance;
|
337 | };
|
338 | return SettingsService;
|
339 | }());
|
340 |
|
341 |
|
342 |
|
343 |
|
344 |
|
345 |
|
346 |
|
347 |
|
348 |
|
349 |
|
350 |
|
351 |
|
352 |
|
353 |
|
354 |
|
355 |
|
356 |
|
357 | var VisibilityState;
|
358 | (function (VisibilityState) {
|
359 | VisibilityState[VisibilityState["UNKNOWN"] = 0] = "UNKNOWN";
|
360 | VisibilityState[VisibilityState["VISIBLE"] = 1] = "VISIBLE";
|
361 | VisibilityState[VisibilityState["HIDDEN"] = 2] = "HIDDEN";
|
362 | })(VisibilityState || (VisibilityState = {}));
|
363 | var RESERVED_ATTRIBUTE_PREFIXES = ['firebase_', 'google_', 'ga_'];
|
364 | var ATTRIBUTE_FORMAT_REGEX = new RegExp('^[a-zA-Z]\\w*$');
|
365 | var MAX_ATTRIBUTE_NAME_LENGTH = 40;
|
366 | var MAX_ATTRIBUTE_VALUE_LENGTH = 100;
|
367 | function getServiceWorkerStatus() {
|
368 | var navigator = Api.getInstance().navigator;
|
369 | if (navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker) {
|
370 | if (navigator.serviceWorker.controller) {
|
371 | return 2 ;
|
372 | }
|
373 | else {
|
374 | return 3 ;
|
375 | }
|
376 | }
|
377 | else {
|
378 | return 1 ;
|
379 | }
|
380 | }
|
381 | function getVisibilityState() {
|
382 | var document = Api.getInstance().document;
|
383 | var visibilityState = document.visibilityState;
|
384 | switch (visibilityState) {
|
385 | case 'visible':
|
386 | return VisibilityState.VISIBLE;
|
387 | case 'hidden':
|
388 | return VisibilityState.HIDDEN;
|
389 | default:
|
390 | return VisibilityState.UNKNOWN;
|
391 | }
|
392 | }
|
393 | function getEffectiveConnectionType() {
|
394 | var navigator = Api.getInstance().navigator;
|
395 | var navigatorConnection = navigator.connection;
|
396 | var effectiveType = navigatorConnection && navigatorConnection.effectiveType;
|
397 | switch (effectiveType) {
|
398 | case 'slow-2g':
|
399 | return 1 ;
|
400 | case '2g':
|
401 | return 2 ;
|
402 | case '3g':
|
403 | return 3 ;
|
404 | case '4g':
|
405 | return 4 ;
|
406 | default:
|
407 | return 0 ;
|
408 | }
|
409 | }
|
410 | function isValidCustomAttributeName(name) {
|
411 | if (name.length === 0 || name.length > MAX_ATTRIBUTE_NAME_LENGTH) {
|
412 | return false;
|
413 | }
|
414 | var matchesReservedPrefix = RESERVED_ATTRIBUTE_PREFIXES.some(function (prefix) {
|
415 | return name.startsWith(prefix);
|
416 | });
|
417 | return !matchesReservedPrefix && !!name.match(ATTRIBUTE_FORMAT_REGEX);
|
418 | }
|
419 | function isValidCustomAttributeValue(value) {
|
420 | return value.length !== 0 && value.length <= MAX_ATTRIBUTE_VALUE_LENGTH;
|
421 | }
|
422 |
|
423 |
|
424 |
|
425 |
|
426 |
|
427 |
|
428 |
|
429 |
|
430 |
|
431 |
|
432 |
|
433 |
|
434 |
|
435 |
|
436 |
|
437 |
|
438 |
|
439 | function getAppId(firebaseApp) {
|
440 | var _a;
|
441 | var appId = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.appId;
|
442 | if (!appId) {
|
443 | throw ERROR_FACTORY.create("no app id" );
|
444 | }
|
445 | return appId;
|
446 | }
|
447 | function getProjectId(firebaseApp) {
|
448 | var _a;
|
449 | var projectId = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.projectId;
|
450 | if (!projectId) {
|
451 | throw ERROR_FACTORY.create("no project id" );
|
452 | }
|
453 | return projectId;
|
454 | }
|
455 | function getApiKey(firebaseApp) {
|
456 | var _a;
|
457 | var apiKey = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.apiKey;
|
458 | if (!apiKey) {
|
459 | throw ERROR_FACTORY.create("no api key" );
|
460 | }
|
461 | return apiKey;
|
462 | }
|
463 |
|
464 |
|
465 |
|
466 |
|
467 |
|
468 |
|
469 |
|
470 |
|
471 |
|
472 |
|
473 |
|
474 |
|
475 |
|
476 |
|
477 |
|
478 |
|
479 |
|
480 | var REMOTE_CONFIG_SDK_VERSION = '0.0.1';
|
481 |
|
482 |
|
483 | var DEFAULT_CONFIGS = {
|
484 | loggingEnabled: true
|
485 | };
|
486 | var FIS_AUTH_PREFIX = 'FIREBASE_INSTALLATIONS_AUTH';
|
487 | function getConfig(performanceController, iid) {
|
488 | var config = getStoredConfig();
|
489 | if (config) {
|
490 | processConfig(config);
|
491 | return Promise.resolve();
|
492 | }
|
493 | return getRemoteConfig(performanceController, iid)
|
494 | .then(processConfig)
|
495 | .then(function (config) { return storeConfig(config); },
|
496 |
|
497 | function () { });
|
498 | }
|
499 | function getStoredConfig() {
|
500 | var localStorage = Api.getInstance().localStorage;
|
501 | if (!localStorage) {
|
502 | return;
|
503 | }
|
504 | var expiryString = localStorage.getItem(CONFIG_EXPIRY_LOCAL_STORAGE_KEY);
|
505 | if (!expiryString || !configValid(expiryString)) {
|
506 | return;
|
507 | }
|
508 | var configStringified = localStorage.getItem(CONFIG_LOCAL_STORAGE_KEY);
|
509 | if (!configStringified) {
|
510 | return;
|
511 | }
|
512 | try {
|
513 | var configResponse = JSON.parse(configStringified);
|
514 | return configResponse;
|
515 | }
|
516 | catch (_a) {
|
517 | return;
|
518 | }
|
519 | }
|
520 | function storeConfig(config) {
|
521 | var localStorage = Api.getInstance().localStorage;
|
522 | if (!config || !localStorage) {
|
523 | return;
|
524 | }
|
525 | localStorage.setItem(CONFIG_LOCAL_STORAGE_KEY, JSON.stringify(config));
|
526 | localStorage.setItem(CONFIG_EXPIRY_LOCAL_STORAGE_KEY, String(Date.now() +
|
527 | SettingsService.getInstance().configTimeToLive * 60 * 60 * 1000));
|
528 | }
|
529 | var COULD_NOT_GET_CONFIG_MSG = 'Could not fetch config, will use default configs';
|
530 | function getRemoteConfig(performanceController, iid) {
|
531 |
|
532 | return getAuthTokenPromise(performanceController.installations)
|
533 | .then(function (authToken) {
|
534 | var projectId = getProjectId(performanceController.app);
|
535 | var apiKey = getApiKey(performanceController.app);
|
536 | var configEndPoint = "https://firebaseremoteconfig.googleapis.com/v1/projects/".concat(projectId, "/namespaces/fireperf:fetch?key=").concat(apiKey);
|
537 | var request = new Request(configEndPoint, {
|
538 | method: 'POST',
|
539 | headers: { Authorization: "".concat(FIS_AUTH_PREFIX, " ").concat(authToken) },
|
540 |
|
541 | body: JSON.stringify({
|
542 | app_instance_id: iid,
|
543 | app_instance_id_token: authToken,
|
544 | app_id: getAppId(performanceController.app),
|
545 | app_version: SDK_VERSION,
|
546 | sdk_version: REMOTE_CONFIG_SDK_VERSION
|
547 | })
|
548 |
|
549 | });
|
550 | return fetch(request).then(function (response) {
|
551 | if (response.ok) {
|
552 | return response.json();
|
553 | }
|
554 |
|
555 | throw ERROR_FACTORY.create("RC response not ok" );
|
556 | });
|
557 | })
|
558 | .catch(function () {
|
559 | consoleLogger.info(COULD_NOT_GET_CONFIG_MSG);
|
560 | return undefined;
|
561 | });
|
562 | }
|
563 |
|
564 |
|
565 |
|
566 |
|
567 |
|
568 | function processConfig(config) {
|
569 | if (!config) {
|
570 | return config;
|
571 | }
|
572 | var settingsServiceInstance = SettingsService.getInstance();
|
573 | var entries = config.entries || {};
|
574 | if (entries.fpr_enabled !== undefined) {
|
575 |
|
576 |
|
577 | settingsServiceInstance.loggingEnabled =
|
578 | String(entries.fpr_enabled) === 'true';
|
579 | }
|
580 | else {
|
581 |
|
582 |
|
583 | settingsServiceInstance.loggingEnabled = DEFAULT_CONFIGS.loggingEnabled;
|
584 | }
|
585 | if (entries.fpr_log_source) {
|
586 | settingsServiceInstance.logSource = Number(entries.fpr_log_source);
|
587 | }
|
588 | else if (DEFAULT_CONFIGS.logSource) {
|
589 | settingsServiceInstance.logSource = DEFAULT_CONFIGS.logSource;
|
590 | }
|
591 | if (entries.fpr_log_endpoint_url) {
|
592 | settingsServiceInstance.logEndPointUrl = entries.fpr_log_endpoint_url;
|
593 | }
|
594 | else if (DEFAULT_CONFIGS.logEndPointUrl) {
|
595 | settingsServiceInstance.logEndPointUrl = DEFAULT_CONFIGS.logEndPointUrl;
|
596 | }
|
597 |
|
598 | if (entries.fpr_log_transport_key) {
|
599 | settingsServiceInstance.transportKey = entries.fpr_log_transport_key;
|
600 | }
|
601 | else if (DEFAULT_CONFIGS.transportKey) {
|
602 | settingsServiceInstance.transportKey = DEFAULT_CONFIGS.transportKey;
|
603 | }
|
604 | if (entries.fpr_vc_network_request_sampling_rate !== undefined) {
|
605 | settingsServiceInstance.networkRequestsSamplingRate = Number(entries.fpr_vc_network_request_sampling_rate);
|
606 | }
|
607 | else if (DEFAULT_CONFIGS.networkRequestsSamplingRate !== undefined) {
|
608 | settingsServiceInstance.networkRequestsSamplingRate =
|
609 | DEFAULT_CONFIGS.networkRequestsSamplingRate;
|
610 | }
|
611 | if (entries.fpr_vc_trace_sampling_rate !== undefined) {
|
612 | settingsServiceInstance.tracesSamplingRate = Number(entries.fpr_vc_trace_sampling_rate);
|
613 | }
|
614 | else if (DEFAULT_CONFIGS.tracesSamplingRate !== undefined) {
|
615 | settingsServiceInstance.tracesSamplingRate =
|
616 | DEFAULT_CONFIGS.tracesSamplingRate;
|
617 | }
|
618 |
|
619 | settingsServiceInstance.logTraceAfterSampling = shouldLogAfterSampling(settingsServiceInstance.tracesSamplingRate);
|
620 | settingsServiceInstance.logNetworkAfterSampling = shouldLogAfterSampling(settingsServiceInstance.networkRequestsSamplingRate);
|
621 | return config;
|
622 | }
|
623 | function configValid(expiry) {
|
624 | return Number(expiry) > Date.now();
|
625 | }
|
626 | function shouldLogAfterSampling(samplingRate) {
|
627 | return Math.random() <= samplingRate;
|
628 | }
|
629 |
|
630 |
|
631 |
|
632 |
|
633 |
|
634 |
|
635 |
|
636 |
|
637 |
|
638 |
|
639 |
|
640 |
|
641 |
|
642 |
|
643 |
|
644 |
|
645 |
|
646 | var initializationStatus = 1 ;
|
647 | var initializationPromise;
|
648 | function getInitializationPromise(performanceController) {
|
649 | initializationStatus = 2 ;
|
650 | initializationPromise =
|
651 | initializationPromise || initializePerf(performanceController);
|
652 | return initializationPromise;
|
653 | }
|
654 | function isPerfInitialized() {
|
655 | return initializationStatus === 3 ;
|
656 | }
|
657 | function initializePerf(performanceController) {
|
658 | return getDocumentReadyComplete()
|
659 | .then(function () { return getIidPromise(performanceController.installations); })
|
660 | .then(function (iid) { return getConfig(performanceController, iid); })
|
661 | .then(function () { return changeInitializationStatus(); }, function () { return changeInitializationStatus(); });
|
662 | }
|
663 |
|
664 |
|
665 |
|
666 |
|
667 | function getDocumentReadyComplete() {
|
668 | var document = Api.getInstance().document;
|
669 | return new Promise(function (resolve) {
|
670 | if (document && document.readyState !== 'complete') {
|
671 | var handler_1 = function () {
|
672 | if (document.readyState === 'complete') {
|
673 | document.removeEventListener('readystatechange', handler_1);
|
674 | resolve();
|
675 | }
|
676 | };
|
677 | document.addEventListener('readystatechange', handler_1);
|
678 | }
|
679 | else {
|
680 | resolve();
|
681 | }
|
682 | });
|
683 | }
|
684 | function changeInitializationStatus() {
|
685 | initializationStatus = 3 ;
|
686 | }
|
687 |
|
688 |
|
689 |
|
690 |
|
691 |
|
692 |
|
693 |
|
694 |
|
695 |
|
696 |
|
697 |
|
698 |
|
699 |
|
700 |
|
701 |
|
702 |
|
703 |
|
704 | var DEFAULT_SEND_INTERVAL_MS = 10 * 1000;
|
705 | var INITIAL_SEND_TIME_DELAY_MS = 5.5 * 1000;
|
706 |
|
707 | var DEFAULT_REMAINING_TRIES = 3;
|
708 | var MAX_EVENT_COUNT_PER_REQUEST = 1000;
|
709 | var remainingTries = DEFAULT_REMAINING_TRIES;
|
710 |
|
711 | var queue = [];
|
712 | var isTransportSetup = false;
|
713 | function setupTransportService() {
|
714 | if (!isTransportSetup) {
|
715 | processQueue(INITIAL_SEND_TIME_DELAY_MS);
|
716 | isTransportSetup = true;
|
717 | }
|
718 | }
|
719 | function processQueue(timeOffset) {
|
720 | setTimeout(function () {
|
721 |
|
722 | if (remainingTries === 0) {
|
723 | return;
|
724 | }
|
725 |
|
726 | if (!queue.length) {
|
727 | return processQueue(DEFAULT_SEND_INTERVAL_MS);
|
728 | }
|
729 | dispatchQueueEvents();
|
730 | }, timeOffset);
|
731 | }
|
732 | function dispatchQueueEvents() {
|
733 |
|
734 |
|
735 |
|
736 | var staged = queue.splice(0, MAX_EVENT_COUNT_PER_REQUEST);
|
737 |
|
738 |
|
739 | var log_event = staged.map(function (evt) { return ({
|
740 | source_extension_json_proto3: evt.message,
|
741 | event_time_ms: String(evt.eventTime)
|
742 | }); });
|
743 | var data = {
|
744 | request_time_ms: String(Date.now()),
|
745 | client_info: {
|
746 | client_type: 1,
|
747 | js_client_info: {}
|
748 | },
|
749 | log_source: SettingsService.getInstance().logSource,
|
750 | log_event: log_event
|
751 | };
|
752 |
|
753 | sendEventsToFl(data, staged).catch(function () {
|
754 |
|
755 |
|
756 | queue = tslib.__spreadArray(tslib.__spreadArray([], staged, true), queue, true);
|
757 | remainingTries--;
|
758 | consoleLogger.info("Tries left: ".concat(remainingTries, "."));
|
759 | processQueue(DEFAULT_SEND_INTERVAL_MS);
|
760 | });
|
761 | }
|
762 | function sendEventsToFl(data, staged) {
|
763 | return postToFlEndpoint(data)
|
764 | .then(function (res) {
|
765 | if (!res.ok) {
|
766 | consoleLogger.info('Call to Firebase backend failed.');
|
767 | }
|
768 | return res.json();
|
769 | })
|
770 | .then(function (res) {
|
771 |
|
772 | var transportWait = Number(res.nextRequestWaitMillis);
|
773 | var requestOffset = DEFAULT_SEND_INTERVAL_MS;
|
774 | if (!isNaN(transportWait)) {
|
775 | requestOffset = Math.max(transportWait, requestOffset);
|
776 | }
|
777 |
|
778 |
|
779 | var logResponseDetails = res.logResponseDetails;
|
780 | if (Array.isArray(logResponseDetails) &&
|
781 | logResponseDetails.length > 0 &&
|
782 | logResponseDetails[0].responseAction === 'RETRY_REQUEST_LATER') {
|
783 | queue = tslib.__spreadArray(tslib.__spreadArray([], staged, true), queue, true);
|
784 | consoleLogger.info("Retry transport request later.");
|
785 | }
|
786 | remainingTries = DEFAULT_REMAINING_TRIES;
|
787 |
|
788 | processQueue(requestOffset);
|
789 | });
|
790 | }
|
791 | function postToFlEndpoint(data) {
|
792 | var flTransportFullUrl = SettingsService.getInstance().getFlTransportFullUrl();
|
793 | return fetch(flTransportFullUrl, {
|
794 | method: 'POST',
|
795 | body: JSON.stringify(data)
|
796 | });
|
797 | }
|
798 | function addToQueue(evt) {
|
799 | if (!evt.eventTime || !evt.message) {
|
800 | throw ERROR_FACTORY.create("invalid cc log" );
|
801 | }
|
802 |
|
803 | queue = tslib.__spreadArray(tslib.__spreadArray([], queue, true), [evt], false);
|
804 | }
|
805 |
|
806 | function transportHandler(
|
807 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
|
808 | serializer) {
|
809 | return function () {
|
810 | var args = [];
|
811 | for (var _i = 0; _i < arguments.length; _i++) {
|
812 | args[_i] = arguments[_i];
|
813 | }
|
814 | var message = serializer.apply(void 0, args);
|
815 | addToQueue({
|
816 | message: message,
|
817 | eventTime: Date.now()
|
818 | });
|
819 | };
|
820 | }
|
821 |
|
822 |
|
823 |
|
824 |
|
825 |
|
826 |
|
827 |
|
828 |
|
829 |
|
830 |
|
831 |
|
832 |
|
833 |
|
834 |
|
835 |
|
836 |
|
837 |
|
838 |
|
839 | var logger;
|
840 |
|
841 | function sendLog(resource, resourceType) {
|
842 | if (!logger) {
|
843 | logger = transportHandler(serializer);
|
844 | }
|
845 | logger(resource, resourceType);
|
846 | }
|
847 | function logTrace(trace) {
|
848 | var settingsService = SettingsService.getInstance();
|
849 |
|
850 | if (!settingsService.instrumentationEnabled && trace.isAuto) {
|
851 | return;
|
852 | }
|
853 |
|
854 | if (!settingsService.dataCollectionEnabled && !trace.isAuto) {
|
855 | return;
|
856 | }
|
857 |
|
858 | if (!Api.getInstance().requiredApisAvailable()) {
|
859 | return;
|
860 | }
|
861 |
|
862 | if (trace.isAuto && getVisibilityState() !== VisibilityState.VISIBLE) {
|
863 | return;
|
864 | }
|
865 | if (isPerfInitialized()) {
|
866 | sendTraceLog(trace);
|
867 | }
|
868 | else {
|
869 |
|
870 |
|
871 | getInitializationPromise(trace.performanceController).then(function () { return sendTraceLog(trace); }, function () { return sendTraceLog(trace); });
|
872 | }
|
873 | }
|
874 | function sendTraceLog(trace) {
|
875 | if (!getIid()) {
|
876 | return;
|
877 | }
|
878 | var settingsService = SettingsService.getInstance();
|
879 | if (!settingsService.loggingEnabled ||
|
880 | !settingsService.logTraceAfterSampling) {
|
881 | return;
|
882 | }
|
883 | setTimeout(function () { return sendLog(trace, 1 ); }, 0);
|
884 | }
|
885 | function logNetworkRequest(networkRequest) {
|
886 | var settingsService = SettingsService.getInstance();
|
887 |
|
888 | if (!settingsService.instrumentationEnabled) {
|
889 | return;
|
890 | }
|
891 |
|
892 |
|
893 | var networkRequestUrl = networkRequest.url;
|
894 |
|
895 |
|
896 | var logEndpointUrl = settingsService.logEndPointUrl.split('?')[0];
|
897 | var flEndpointUrl = settingsService.flTransportEndpointUrl.split('?')[0];
|
898 | if (networkRequestUrl === logEndpointUrl ||
|
899 | networkRequestUrl === flEndpointUrl) {
|
900 | return;
|
901 | }
|
902 | if (!settingsService.loggingEnabled ||
|
903 | !settingsService.logNetworkAfterSampling) {
|
904 | return;
|
905 | }
|
906 | setTimeout(function () { return sendLog(networkRequest, 0 ); }, 0);
|
907 | }
|
908 | function serializer(resource, resourceType) {
|
909 | if (resourceType === 0 ) {
|
910 | return serializeNetworkRequest(resource);
|
911 | }
|
912 | return serializeTrace(resource);
|
913 | }
|
914 | function serializeNetworkRequest(networkRequest) {
|
915 | var networkRequestMetric = {
|
916 | url: networkRequest.url,
|
917 | http_method: networkRequest.httpMethod || 0,
|
918 | http_response_code: 200,
|
919 | response_payload_bytes: networkRequest.responsePayloadBytes,
|
920 | client_start_time_us: networkRequest.startTimeUs,
|
921 | time_to_response_initiated_us: networkRequest.timeToResponseInitiatedUs,
|
922 | time_to_response_completed_us: networkRequest.timeToResponseCompletedUs
|
923 | };
|
924 | var perfMetric = {
|
925 | application_info: getApplicationInfo(networkRequest.performanceController.app),
|
926 | network_request_metric: networkRequestMetric
|
927 | };
|
928 | return JSON.stringify(perfMetric);
|
929 | }
|
930 | function serializeTrace(trace) {
|
931 | var traceMetric = {
|
932 | name: trace.name,
|
933 | is_auto: trace.isAuto,
|
934 | client_start_time_us: trace.startTimeUs,
|
935 | duration_us: trace.durationUs
|
936 | };
|
937 | if (Object.keys(trace.counters).length !== 0) {
|
938 | traceMetric.counters = trace.counters;
|
939 | }
|
940 | var customAttributes = trace.getAttributes();
|
941 | if (Object.keys(customAttributes).length !== 0) {
|
942 | traceMetric.custom_attributes = customAttributes;
|
943 | }
|
944 | var perfMetric = {
|
945 | application_info: getApplicationInfo(trace.performanceController.app),
|
946 | trace_metric: traceMetric
|
947 | };
|
948 | return JSON.stringify(perfMetric);
|
949 | }
|
950 | function getApplicationInfo(firebaseApp) {
|
951 | return {
|
952 | google_app_id: getAppId(firebaseApp),
|
953 | app_instance_id: getIid(),
|
954 | web_app_info: {
|
955 | sdk_version: SDK_VERSION,
|
956 | page_url: Api.getInstance().getUrl(),
|
957 | service_worker_status: getServiceWorkerStatus(),
|
958 | visibility_state: getVisibilityState(),
|
959 | effective_connection_type: getEffectiveConnectionType()
|
960 | },
|
961 | application_process_state: 0
|
962 | };
|
963 | }
|
964 |
|
965 |
|
966 |
|
967 |
|
968 |
|
969 |
|
970 |
|
971 |
|
972 |
|
973 |
|
974 |
|
975 |
|
976 |
|
977 |
|
978 |
|
979 |
|
980 |
|
981 | var MAX_METRIC_NAME_LENGTH = 100;
|
982 | var RESERVED_AUTO_PREFIX = '_';
|
983 | var oobMetrics = [
|
984 | FIRST_PAINT_COUNTER_NAME,
|
985 | FIRST_CONTENTFUL_PAINT_COUNTER_NAME,
|
986 | FIRST_INPUT_DELAY_COUNTER_NAME
|
987 | ];
|
988 |
|
989 |
|
990 |
|
991 |
|
992 | function isValidMetricName(name, traceName) {
|
993 | if (name.length === 0 || name.length > MAX_METRIC_NAME_LENGTH) {
|
994 | return false;
|
995 | }
|
996 | return ((traceName &&
|
997 | traceName.startsWith(OOB_TRACE_PAGE_LOAD_PREFIX) &&
|
998 | oobMetrics.indexOf(name) > -1) ||
|
999 | !name.startsWith(RESERVED_AUTO_PREFIX));
|
1000 | }
|
1001 |
|
1002 |
|
1003 |
|
1004 |
|
1005 |
|
1006 |
|
1007 | function convertMetricValueToInteger(providedValue) {
|
1008 | var valueAsInteger = Math.floor(providedValue);
|
1009 | if (valueAsInteger < providedValue) {
|
1010 | consoleLogger.info("Metric value should be an Integer, setting the value as : ".concat(valueAsInteger, "."));
|
1011 | }
|
1012 | return valueAsInteger;
|
1013 | }
|
1014 |
|
1015 |
|
1016 |
|
1017 |
|
1018 |
|
1019 |
|
1020 |
|
1021 |
|
1022 |
|
1023 |
|
1024 |
|
1025 |
|
1026 |
|
1027 |
|
1028 |
|
1029 |
|
1030 |
|
1031 | var Trace = (function () {
|
1032 | |
1033 |
|
1034 |
|
1035 |
|
1036 |
|
1037 |
|
1038 |
|
1039 |
|
1040 | function Trace(performanceController, name, isAuto, traceMeasureName) {
|
1041 | if (isAuto === void 0) { isAuto = false; }
|
1042 | this.performanceController = performanceController;
|
1043 | this.name = name;
|
1044 | this.isAuto = isAuto;
|
1045 | this.state = 1 ;
|
1046 | this.customAttributes = {};
|
1047 | this.counters = {};
|
1048 | this.api = Api.getInstance();
|
1049 | this.randomId = Math.floor(Math.random() * 1000000);
|
1050 | if (!this.isAuto) {
|
1051 | this.traceStartMark = "".concat(TRACE_START_MARK_PREFIX, "-").concat(this.randomId, "-").concat(this.name);
|
1052 | this.traceStopMark = "".concat(TRACE_STOP_MARK_PREFIX, "-").concat(this.randomId, "-").concat(this.name);
|
1053 | this.traceMeasure =
|
1054 | traceMeasureName ||
|
1055 | "".concat(TRACE_MEASURE_PREFIX, "-").concat(this.randomId, "-").concat(this.name);
|
1056 | if (traceMeasureName) {
|
1057 |
|
1058 |
|
1059 | this.calculateTraceMetrics();
|
1060 | }
|
1061 | }
|
1062 | }
|
1063 | |
1064 |
|
1065 |
|
1066 | Trace.prototype.start = function () {
|
1067 | if (this.state !== 1 ) {
|
1068 | throw ERROR_FACTORY.create("trace started" , {
|
1069 | traceName: this.name
|
1070 | });
|
1071 | }
|
1072 | this.api.mark(this.traceStartMark);
|
1073 | this.state = 2 ;
|
1074 | };
|
1075 | |
1076 |
|
1077 |
|
1078 |
|
1079 | Trace.prototype.stop = function () {
|
1080 | if (this.state !== 2 ) {
|
1081 | throw ERROR_FACTORY.create("trace stopped" , {
|
1082 | traceName: this.name
|
1083 | });
|
1084 | }
|
1085 | this.state = 3 ;
|
1086 | this.api.mark(this.traceStopMark);
|
1087 | this.api.measure(this.traceMeasure, this.traceStartMark, this.traceStopMark);
|
1088 | this.calculateTraceMetrics();
|
1089 | logTrace(this);
|
1090 | };
|
1091 | |
1092 |
|
1093 |
|
1094 |
|
1095 |
|
1096 |
|
1097 |
|
1098 | Trace.prototype.record = function (startTime, duration, options) {
|
1099 | if (startTime <= 0) {
|
1100 | throw ERROR_FACTORY.create("nonpositive trace startTime" , {
|
1101 | traceName: this.name
|
1102 | });
|
1103 | }
|
1104 | if (duration <= 0) {
|
1105 | throw ERROR_FACTORY.create("nonpositive trace duration" , {
|
1106 | traceName: this.name
|
1107 | });
|
1108 | }
|
1109 | this.durationUs = Math.floor(duration * 1000);
|
1110 | this.startTimeUs = Math.floor(startTime * 1000);
|
1111 | if (options && options.attributes) {
|
1112 | this.customAttributes = tslib.__assign({}, options.attributes);
|
1113 | }
|
1114 | if (options && options.metrics) {
|
1115 | for (var _i = 0, _a = Object.keys(options.metrics); _i < _a.length; _i++) {
|
1116 | var metricName = _a[_i];
|
1117 | if (!isNaN(Number(options.metrics[metricName]))) {
|
1118 | this.counters[metricName] = Math.floor(Number(options.metrics[metricName]));
|
1119 | }
|
1120 | }
|
1121 | }
|
1122 | logTrace(this);
|
1123 | };
|
1124 | |
1125 |
|
1126 |
|
1127 |
|
1128 |
|
1129 |
|
1130 |
|
1131 | Trace.prototype.incrementMetric = function (counter, numAsInteger) {
|
1132 | if (numAsInteger === void 0) { numAsInteger = 1; }
|
1133 | if (this.counters[counter] === undefined) {
|
1134 | this.putMetric(counter, numAsInteger);
|
1135 | }
|
1136 | else {
|
1137 | this.putMetric(counter, this.counters[counter] + numAsInteger);
|
1138 | }
|
1139 | };
|
1140 | |
1141 |
|
1142 |
|
1143 |
|
1144 |
|
1145 |
|
1146 | Trace.prototype.putMetric = function (counter, numAsInteger) {
|
1147 | if (isValidMetricName(counter, this.name)) {
|
1148 | this.counters[counter] = convertMetricValueToInteger(numAsInteger !== null && numAsInteger !== void 0 ? numAsInteger : 0);
|
1149 | }
|
1150 | else {
|
1151 | throw ERROR_FACTORY.create("invalid custom metric name" , {
|
1152 | customMetricName: counter
|
1153 | });
|
1154 | }
|
1155 | };
|
1156 | |
1157 |
|
1158 |
|
1159 |
|
1160 |
|
1161 | Trace.prototype.getMetric = function (counter) {
|
1162 | return this.counters[counter] || 0;
|
1163 | };
|
1164 | |
1165 |
|
1166 |
|
1167 |
|
1168 |
|
1169 | Trace.prototype.putAttribute = function (attr, value) {
|
1170 | var isValidName = isValidCustomAttributeName(attr);
|
1171 | var isValidValue = isValidCustomAttributeValue(value);
|
1172 | if (isValidName && isValidValue) {
|
1173 | this.customAttributes[attr] = value;
|
1174 | return;
|
1175 | }
|
1176 |
|
1177 | if (!isValidName) {
|
1178 | throw ERROR_FACTORY.create("invalid attribute name" , {
|
1179 | attributeName: attr
|
1180 | });
|
1181 | }
|
1182 | if (!isValidValue) {
|
1183 | throw ERROR_FACTORY.create("invalid attribute value" , {
|
1184 | attributeValue: value
|
1185 | });
|
1186 | }
|
1187 | };
|
1188 | |
1189 |
|
1190 |
|
1191 |
|
1192 | Trace.prototype.getAttribute = function (attr) {
|
1193 | return this.customAttributes[attr];
|
1194 | };
|
1195 | Trace.prototype.removeAttribute = function (attr) {
|
1196 | if (this.customAttributes[attr] === undefined) {
|
1197 | return;
|
1198 | }
|
1199 | delete this.customAttributes[attr];
|
1200 | };
|
1201 | Trace.prototype.getAttributes = function () {
|
1202 | return tslib.__assign({}, this.customAttributes);
|
1203 | };
|
1204 | Trace.prototype.setStartTime = function (startTime) {
|
1205 | this.startTimeUs = startTime;
|
1206 | };
|
1207 | Trace.prototype.setDuration = function (duration) {
|
1208 | this.durationUs = duration;
|
1209 | };
|
1210 | |
1211 |
|
1212 |
|
1213 |
|
1214 | Trace.prototype.calculateTraceMetrics = function () {
|
1215 | var perfMeasureEntries = this.api.getEntriesByName(this.traceMeasure);
|
1216 | var perfMeasureEntry = perfMeasureEntries && perfMeasureEntries[0];
|
1217 | if (perfMeasureEntry) {
|
1218 | this.durationUs = Math.floor(perfMeasureEntry.duration * 1000);
|
1219 | this.startTimeUs = Math.floor((perfMeasureEntry.startTime + this.api.getTimeOrigin()) * 1000);
|
1220 | }
|
1221 | };
|
1222 | |
1223 |
|
1224 |
|
1225 |
|
1226 |
|
1227 |
|
1228 | Trace.createOobTrace = function (performanceController, navigationTimings, paintTimings, firstInputDelay) {
|
1229 | var route = Api.getInstance().getUrl();
|
1230 | if (!route) {
|
1231 | return;
|
1232 | }
|
1233 | var trace = new Trace(performanceController, OOB_TRACE_PAGE_LOAD_PREFIX + route, true);
|
1234 | var timeOriginUs = Math.floor(Api.getInstance().getTimeOrigin() * 1000);
|
1235 | trace.setStartTime(timeOriginUs);
|
1236 |
|
1237 | if (navigationTimings && navigationTimings[0]) {
|
1238 | trace.setDuration(Math.floor(navigationTimings[0].duration * 1000));
|
1239 | trace.putMetric('domInteractive', Math.floor(navigationTimings[0].domInteractive * 1000));
|
1240 | trace.putMetric('domContentLoadedEventEnd', Math.floor(navigationTimings[0].domContentLoadedEventEnd * 1000));
|
1241 | trace.putMetric('loadEventEnd', Math.floor(navigationTimings[0].loadEventEnd * 1000));
|
1242 | }
|
1243 | var FIRST_PAINT = 'first-paint';
|
1244 | var FIRST_CONTENTFUL_PAINT = 'first-contentful-paint';
|
1245 | if (paintTimings) {
|
1246 | var firstPaint = paintTimings.find(function (paintObject) { return paintObject.name === FIRST_PAINT; });
|
1247 | if (firstPaint && firstPaint.startTime) {
|
1248 | trace.putMetric(FIRST_PAINT_COUNTER_NAME, Math.floor(firstPaint.startTime * 1000));
|
1249 | }
|
1250 | var firstContentfulPaint = paintTimings.find(function (paintObject) { return paintObject.name === FIRST_CONTENTFUL_PAINT; });
|
1251 | if (firstContentfulPaint && firstContentfulPaint.startTime) {
|
1252 | trace.putMetric(FIRST_CONTENTFUL_PAINT_COUNTER_NAME, Math.floor(firstContentfulPaint.startTime * 1000));
|
1253 | }
|
1254 | if (firstInputDelay) {
|
1255 | trace.putMetric(FIRST_INPUT_DELAY_COUNTER_NAME, Math.floor(firstInputDelay * 1000));
|
1256 | }
|
1257 | }
|
1258 | logTrace(trace);
|
1259 | };
|
1260 | Trace.createUserTimingTrace = function (performanceController, measureName) {
|
1261 | var trace = new Trace(performanceController, measureName, false, measureName);
|
1262 | logTrace(trace);
|
1263 | };
|
1264 | return Trace;
|
1265 | }());
|
1266 |
|
1267 |
|
1268 |
|
1269 |
|
1270 |
|
1271 |
|
1272 |
|
1273 |
|
1274 |
|
1275 |
|
1276 |
|
1277 |
|
1278 |
|
1279 |
|
1280 |
|
1281 |
|
1282 |
|
1283 | function createNetworkRequestEntry(performanceController, entry) {
|
1284 | var performanceEntry = entry;
|
1285 | if (!performanceEntry || performanceEntry.responseStart === undefined) {
|
1286 | return;
|
1287 | }
|
1288 | var timeOrigin = Api.getInstance().getTimeOrigin();
|
1289 | var startTimeUs = Math.floor((performanceEntry.startTime + timeOrigin) * 1000);
|
1290 | var timeToResponseInitiatedUs = performanceEntry.responseStart
|
1291 | ? Math.floor((performanceEntry.responseStart - performanceEntry.startTime) * 1000)
|
1292 | : undefined;
|
1293 | var timeToResponseCompletedUs = Math.floor((performanceEntry.responseEnd - performanceEntry.startTime) * 1000);
|
1294 |
|
1295 | var url = performanceEntry.name && performanceEntry.name.split('?')[0];
|
1296 | var networkRequest = {
|
1297 | performanceController: performanceController,
|
1298 | url: url,
|
1299 | responsePayloadBytes: performanceEntry.transferSize,
|
1300 | startTimeUs: startTimeUs,
|
1301 | timeToResponseInitiatedUs: timeToResponseInitiatedUs,
|
1302 | timeToResponseCompletedUs: timeToResponseCompletedUs
|
1303 | };
|
1304 | logNetworkRequest(networkRequest);
|
1305 | }
|
1306 |
|
1307 |
|
1308 |
|
1309 |
|
1310 |
|
1311 |
|
1312 |
|
1313 |
|
1314 |
|
1315 |
|
1316 |
|
1317 |
|
1318 |
|
1319 |
|
1320 |
|
1321 |
|
1322 |
|
1323 | var FID_WAIT_TIME_MS = 5000;
|
1324 | function setupOobResources(performanceController) {
|
1325 |
|
1326 | if (!getIid()) {
|
1327 | return;
|
1328 | }
|
1329 |
|
1330 |
|
1331 | setTimeout(function () { return setupOobTraces(performanceController); }, 0);
|
1332 | setTimeout(function () { return setupNetworkRequests(performanceController); }, 0);
|
1333 | setTimeout(function () { return setupUserTimingTraces(performanceController); }, 0);
|
1334 | }
|
1335 | function setupNetworkRequests(performanceController) {
|
1336 | var api = Api.getInstance();
|
1337 | var resources = api.getEntriesByType('resource');
|
1338 | for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
|
1339 | var resource = resources_1[_i];
|
1340 | createNetworkRequestEntry(performanceController, resource);
|
1341 | }
|
1342 | api.setupObserver('resource', function (entry) {
|
1343 | return createNetworkRequestEntry(performanceController, entry);
|
1344 | });
|
1345 | }
|
1346 | function setupOobTraces(performanceController) {
|
1347 | var api = Api.getInstance();
|
1348 | var navigationTimings = api.getEntriesByType('navigation');
|
1349 | var paintTimings = api.getEntriesByType('paint');
|
1350 |
|
1351 |
|
1352 | if (api.onFirstInputDelay) {
|
1353 |
|
1354 |
|
1355 | var timeoutId_1 = setTimeout(function () {
|
1356 | Trace.createOobTrace(performanceController, navigationTimings, paintTimings);
|
1357 | timeoutId_1 = undefined;
|
1358 | }, FID_WAIT_TIME_MS);
|
1359 | api.onFirstInputDelay(function (fid) {
|
1360 | if (timeoutId_1) {
|
1361 | clearTimeout(timeoutId_1);
|
1362 | Trace.createOobTrace(performanceController, navigationTimings, paintTimings, fid);
|
1363 | }
|
1364 | });
|
1365 | }
|
1366 | else {
|
1367 | Trace.createOobTrace(performanceController, navigationTimings, paintTimings);
|
1368 | }
|
1369 | }
|
1370 | function setupUserTimingTraces(performanceController) {
|
1371 | var api = Api.getInstance();
|
1372 |
|
1373 | var measures = api.getEntriesByType('measure');
|
1374 | for (var _i = 0, measures_1 = measures; _i < measures_1.length; _i++) {
|
1375 | var measure = measures_1[_i];
|
1376 | createUserTimingTrace(performanceController, measure);
|
1377 | }
|
1378 |
|
1379 | api.setupObserver('measure', function (entry) {
|
1380 | return createUserTimingTrace(performanceController, entry);
|
1381 | });
|
1382 | }
|
1383 | function createUserTimingTrace(performanceController, measure) {
|
1384 | var measureName = measure.name;
|
1385 |
|
1386 | if (measureName.substring(0, TRACE_MEASURE_PREFIX.length) ===
|
1387 | TRACE_MEASURE_PREFIX) {
|
1388 | return;
|
1389 | }
|
1390 | Trace.createUserTimingTrace(performanceController, measureName);
|
1391 | }
|
1392 |
|
1393 |
|
1394 |
|
1395 |
|
1396 |
|
1397 |
|
1398 |
|
1399 |
|
1400 |
|
1401 |
|
1402 |
|
1403 |
|
1404 |
|
1405 |
|
1406 |
|
1407 |
|
1408 |
|
1409 | var PerformanceController = (function () {
|
1410 | function PerformanceController(app, installations) {
|
1411 | this.app = app;
|
1412 | this.installations = installations;
|
1413 | this.initialized = false;
|
1414 | }
|
1415 | |
1416 |
|
1417 |
|
1418 |
|
1419 |
|
1420 |
|
1421 |
|
1422 |
|
1423 |
|
1424 | PerformanceController.prototype._init = function (settings) {
|
1425 | var _this = this;
|
1426 | if (this.initialized) {
|
1427 | return;
|
1428 | }
|
1429 | if ((settings === null || settings === void 0 ? void 0 : settings.dataCollectionEnabled) !== undefined) {
|
1430 | this.dataCollectionEnabled = settings.dataCollectionEnabled;
|
1431 | }
|
1432 | if ((settings === null || settings === void 0 ? void 0 : settings.instrumentationEnabled) !== undefined) {
|
1433 | this.instrumentationEnabled = settings.instrumentationEnabled;
|
1434 | }
|
1435 | if (Api.getInstance().requiredApisAvailable()) {
|
1436 | util.validateIndexedDBOpenable()
|
1437 | .then(function (isAvailable) {
|
1438 | if (isAvailable) {
|
1439 | setupTransportService();
|
1440 | getInitializationPromise(_this).then(function () { return setupOobResources(_this); }, function () { return setupOobResources(_this); });
|
1441 | _this.initialized = true;
|
1442 | }
|
1443 | })
|
1444 | .catch(function (error) {
|
1445 | consoleLogger.info("Environment doesn't support IndexedDB: ".concat(error));
|
1446 | });
|
1447 | }
|
1448 | else {
|
1449 | consoleLogger.info('Firebase Performance cannot start if the browser does not support ' +
|
1450 | '"Fetch" and "Promise", or cookies are disabled.');
|
1451 | }
|
1452 | };
|
1453 | Object.defineProperty(PerformanceController.prototype, "instrumentationEnabled", {
|
1454 | get: function () {
|
1455 | return SettingsService.getInstance().instrumentationEnabled;
|
1456 | },
|
1457 | set: function (val) {
|
1458 | SettingsService.getInstance().instrumentationEnabled = val;
|
1459 | },
|
1460 | enumerable: false,
|
1461 | configurable: true
|
1462 | });
|
1463 | Object.defineProperty(PerformanceController.prototype, "dataCollectionEnabled", {
|
1464 | get: function () {
|
1465 | return SettingsService.getInstance().dataCollectionEnabled;
|
1466 | },
|
1467 | set: function (val) {
|
1468 | SettingsService.getInstance().dataCollectionEnabled = val;
|
1469 | },
|
1470 | enumerable: false,
|
1471 | configurable: true
|
1472 | });
|
1473 | return PerformanceController;
|
1474 | }());
|
1475 |
|
1476 |
|
1477 |
|
1478 |
|
1479 |
|
1480 |
|
1481 |
|
1482 | var DEFAULT_ENTRY_NAME = '[DEFAULT]';
|
1483 |
|
1484 |
|
1485 |
|
1486 |
|
1487 |
|
1488 | function getPerformance(app$1) {
|
1489 | if (app$1 === void 0) { app$1 = app.getApp(); }
|
1490 | app$1 = util.getModularInstance(app$1);
|
1491 | var provider = app._getProvider(app$1, 'performance');
|
1492 | var perfInstance = provider.getImmediate();
|
1493 | return perfInstance;
|
1494 | }
|
1495 |
|
1496 |
|
1497 |
|
1498 |
|
1499 |
|
1500 |
|
1501 | function initializePerformance(app$1, settings) {
|
1502 | app$1 = util.getModularInstance(app$1);
|
1503 | var provider = app._getProvider(app$1, 'performance');
|
1504 |
|
1505 |
|
1506 | if (provider.isInitialized()) {
|
1507 | var existingInstance = provider.getImmediate();
|
1508 | var initialSettings = provider.getOptions();
|
1509 | if (util.deepEqual(initialSettings, settings !== null && settings !== void 0 ? settings : {})) {
|
1510 | return existingInstance;
|
1511 | }
|
1512 | else {
|
1513 | throw ERROR_FACTORY.create("already initialized" );
|
1514 | }
|
1515 | }
|
1516 | var perfInstance = provider.initialize({
|
1517 | options: settings
|
1518 | });
|
1519 | return perfInstance;
|
1520 | }
|
1521 |
|
1522 |
|
1523 |
|
1524 |
|
1525 |
|
1526 |
|
1527 | function trace(performance, name) {
|
1528 | performance = util.getModularInstance(performance);
|
1529 | return new Trace(performance, name);
|
1530 | }
|
1531 | var factory = function (container, _a) {
|
1532 | var settings = _a.options;
|
1533 |
|
1534 | var app = container.getProvider('app').getImmediate();
|
1535 | var installations = container
|
1536 | .getProvider('installations-internal')
|
1537 | .getImmediate();
|
1538 | if (app.name !== DEFAULT_ENTRY_NAME) {
|
1539 | throw ERROR_FACTORY.create("FB not default" );
|
1540 | }
|
1541 | if (typeof window === 'undefined') {
|
1542 | throw ERROR_FACTORY.create("no window" );
|
1543 | }
|
1544 | setupApi(window);
|
1545 | var perfInstance = new PerformanceController(app, installations);
|
1546 | perfInstance._init(settings);
|
1547 | return perfInstance;
|
1548 | };
|
1549 | function registerPerformance() {
|
1550 | app._registerComponent(new component.Component('performance', factory, "PUBLIC" ));
|
1551 | app.registerVersion(name, version);
|
1552 |
|
1553 | app.registerVersion(name, version, 'cjs5');
|
1554 | }
|
1555 | registerPerformance();
|
1556 |
|
1557 | exports.getPerformance = getPerformance;
|
1558 | exports.initializePerformance = initializePerformance;
|
1559 | exports.trace = trace;
|
1560 |
|