1561 lines
64 KiB
JavaScript
1561 lines
64 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
var util = require('@firebase/util');
|
|
var logger$1 = require('@firebase/logger');
|
|
var tslib = require('tslib');
|
|
var app = require('@firebase/app');
|
|
var component = require('@firebase/component');
|
|
require('@firebase/installations');
|
|
|
|
var name = "@firebase/performance";
|
|
var version = "0.6.5";
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var SDK_VERSION = version;
|
|
/** The prefix for start User Timing marks used for creating Traces. */
|
|
var TRACE_START_MARK_PREFIX = 'FB-PERF-TRACE-START';
|
|
/** The prefix for stop User Timing marks used for creating Traces. */
|
|
var TRACE_STOP_MARK_PREFIX = 'FB-PERF-TRACE-STOP';
|
|
/** The prefix for User Timing measure used for creating Traces. */
|
|
var TRACE_MEASURE_PREFIX = 'FB-PERF-TRACE-MEASURE';
|
|
/** The prefix for out of the box page load Trace name. */
|
|
var OOB_TRACE_PAGE_LOAD_PREFIX = '_wt_';
|
|
var FIRST_PAINT_COUNTER_NAME = '_fp';
|
|
var FIRST_CONTENTFUL_PAINT_COUNTER_NAME = '_fcp';
|
|
var FIRST_INPUT_DELAY_COUNTER_NAME = '_fid';
|
|
var CONFIG_LOCAL_STORAGE_KEY = '@firebase/performance/config';
|
|
var CONFIG_EXPIRY_LOCAL_STORAGE_KEY = '@firebase/performance/configexpire';
|
|
var SERVICE = 'performance';
|
|
var SERVICE_NAME = 'Performance';
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var _a;
|
|
var ERROR_DESCRIPTION_MAP = (_a = {},
|
|
_a["trace started" /* ErrorCode.TRACE_STARTED_BEFORE */] = 'Trace {$traceName} was started before.',
|
|
_a["trace stopped" /* ErrorCode.TRACE_STOPPED_BEFORE */] = 'Trace {$traceName} is not running.',
|
|
_a["nonpositive trace startTime" /* ErrorCode.NONPOSITIVE_TRACE_START_TIME */] = 'Trace {$traceName} startTime should be positive.',
|
|
_a["nonpositive trace duration" /* ErrorCode.NONPOSITIVE_TRACE_DURATION */] = 'Trace {$traceName} duration should be positive.',
|
|
_a["no window" /* ErrorCode.NO_WINDOW */] = 'Window is not available.',
|
|
_a["no app id" /* ErrorCode.NO_APP_ID */] = 'App id is not available.',
|
|
_a["no project id" /* ErrorCode.NO_PROJECT_ID */] = 'Project id is not available.',
|
|
_a["no api key" /* ErrorCode.NO_API_KEY */] = 'Api key is not available.',
|
|
_a["invalid cc log" /* ErrorCode.INVALID_CC_LOG */] = 'Attempted to queue invalid cc event',
|
|
_a["FB not default" /* ErrorCode.FB_NOT_DEFAULT */] = 'Performance can only start when Firebase app instance is the default one.',
|
|
_a["RC response not ok" /* ErrorCode.RC_NOT_OK */] = 'RC response is not ok',
|
|
_a["invalid attribute name" /* ErrorCode.INVALID_ATTRIBUTE_NAME */] = 'Attribute name {$attributeName} is invalid.',
|
|
_a["invalid attribute value" /* ErrorCode.INVALID_ATTRIBUTE_VALUE */] = 'Attribute value {$attributeValue} is invalid.',
|
|
_a["invalid custom metric name" /* ErrorCode.INVALID_CUSTOM_METRIC_NAME */] = 'Custom metric name {$customMetricName} is invalid',
|
|
_a["invalid String merger input" /* ErrorCode.INVALID_STRING_MERGER_PARAMETER */] = 'Input for String merger is invalid, contact support team to resolve.',
|
|
_a["already initialized" /* ErrorCode.ALREADY_INITIALIZED */] = 'initializePerformance() has already been called with ' +
|
|
'different options. To avoid this error, call initializePerformance() with the ' +
|
|
'same options as when it was originally called, or call getPerformance() to return the' +
|
|
' already initialized instance.',
|
|
_a);
|
|
var ERROR_FACTORY = new util.ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP);
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var consoleLogger = new logger$1.Logger(SERVICE_NAME);
|
|
consoleLogger.logLevel = logger$1.LogLevel.INFO;
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var apiInstance;
|
|
var windowInstance;
|
|
/**
|
|
* This class holds a reference to various browser related objects injected by
|
|
* set methods.
|
|
*/
|
|
var Api = /** @class */ (function () {
|
|
function Api(window) {
|
|
this.window = window;
|
|
if (!window) {
|
|
throw ERROR_FACTORY.create("no window" /* ErrorCode.NO_WINDOW */);
|
|
}
|
|
this.performance = window.performance;
|
|
this.PerformanceObserver = window.PerformanceObserver;
|
|
this.windowLocation = window.location;
|
|
this.navigator = window.navigator;
|
|
this.document = window.document;
|
|
if (this.navigator && this.navigator.cookieEnabled) {
|
|
// If user blocks cookies on the browser, accessing localStorage will
|
|
// throw an exception.
|
|
this.localStorage = window.localStorage;
|
|
}
|
|
if (window.perfMetrics && window.perfMetrics.onFirstInputDelay) {
|
|
this.onFirstInputDelay = window.perfMetrics.onFirstInputDelay;
|
|
}
|
|
}
|
|
Api.prototype.getUrl = function () {
|
|
// Do not capture the string query part of url.
|
|
return this.windowLocation.href.split('?')[0];
|
|
};
|
|
Api.prototype.mark = function (name) {
|
|
if (!this.performance || !this.performance.mark) {
|
|
return;
|
|
}
|
|
this.performance.mark(name);
|
|
};
|
|
Api.prototype.measure = function (measureName, mark1, mark2) {
|
|
if (!this.performance || !this.performance.measure) {
|
|
return;
|
|
}
|
|
this.performance.measure(measureName, mark1, mark2);
|
|
};
|
|
Api.prototype.getEntriesByType = function (type) {
|
|
if (!this.performance || !this.performance.getEntriesByType) {
|
|
return [];
|
|
}
|
|
return this.performance.getEntriesByType(type);
|
|
};
|
|
Api.prototype.getEntriesByName = function (name) {
|
|
if (!this.performance || !this.performance.getEntriesByName) {
|
|
return [];
|
|
}
|
|
return this.performance.getEntriesByName(name);
|
|
};
|
|
Api.prototype.getTimeOrigin = function () {
|
|
// Polyfill the time origin with performance.timing.navigationStart.
|
|
return (this.performance &&
|
|
(this.performance.timeOrigin || this.performance.timing.navigationStart));
|
|
};
|
|
Api.prototype.requiredApisAvailable = function () {
|
|
if (!fetch || !Promise || !util.areCookiesEnabled()) {
|
|
consoleLogger.info('Firebase Performance cannot start if browser does not support fetch and Promise or cookie is disabled.');
|
|
return false;
|
|
}
|
|
if (!util.isIndexedDBAvailable()) {
|
|
consoleLogger.info('IndexedDB is not supported by current browser');
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
Api.prototype.setupObserver = function (entryType, callback) {
|
|
if (!this.PerformanceObserver) {
|
|
return;
|
|
}
|
|
var observer = new this.PerformanceObserver(function (list) {
|
|
for (var _i = 0, _a = list.getEntries(); _i < _a.length; _i++) {
|
|
var entry = _a[_i];
|
|
// `entry` is a PerformanceEntry instance.
|
|
callback(entry);
|
|
}
|
|
});
|
|
// Start observing the entry types you care about.
|
|
observer.observe({ entryTypes: [entryType] });
|
|
};
|
|
Api.getInstance = function () {
|
|
if (apiInstance === undefined) {
|
|
apiInstance = new Api(windowInstance);
|
|
}
|
|
return apiInstance;
|
|
};
|
|
return Api;
|
|
}());
|
|
function setupApi(window) {
|
|
windowInstance = window;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var iid;
|
|
function getIidPromise(installationsService) {
|
|
var iidPromise = installationsService.getId();
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
iidPromise.then(function (iidVal) {
|
|
iid = iidVal;
|
|
});
|
|
return iidPromise;
|
|
}
|
|
// This method should be used after the iid is retrieved by getIidPromise method.
|
|
function getIid() {
|
|
return iid;
|
|
}
|
|
function getAuthTokenPromise(installationsService) {
|
|
var authTokenPromise = installationsService.getToken();
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
authTokenPromise.then(function (authTokenVal) {
|
|
});
|
|
return authTokenPromise;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function mergeStrings(part1, part2) {
|
|
var sizeDiff = part1.length - part2.length;
|
|
if (sizeDiff < 0 || sizeDiff > 1) {
|
|
throw ERROR_FACTORY.create("invalid String merger input" /* ErrorCode.INVALID_STRING_MERGER_PARAMETER */);
|
|
}
|
|
var resultArray = [];
|
|
for (var i = 0; i < part1.length; i++) {
|
|
resultArray.push(part1.charAt(i));
|
|
if (part2.length > i) {
|
|
resultArray.push(part2.charAt(i));
|
|
}
|
|
}
|
|
return resultArray.join('');
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var settingsServiceInstance;
|
|
var SettingsService = /** @class */ (function () {
|
|
function SettingsService() {
|
|
// The variable which controls logging of automatic traces and HTTP/S network monitoring.
|
|
this.instrumentationEnabled = true;
|
|
// The variable which controls logging of custom traces.
|
|
this.dataCollectionEnabled = true;
|
|
// Configuration flags set through remote config.
|
|
this.loggingEnabled = false;
|
|
// Sampling rate between 0 and 1.
|
|
this.tracesSamplingRate = 1;
|
|
this.networkRequestsSamplingRate = 1;
|
|
// Address of logging service.
|
|
this.logEndPointUrl = 'https://firebaselogging.googleapis.com/v0cc/log?format=json_proto';
|
|
// Performance event transport endpoint URL which should be compatible with proto3.
|
|
// New Address for transport service, not configurable via Remote Config.
|
|
this.flTransportEndpointUrl = mergeStrings('hts/frbslgigp.ogepscmv/ieo/eaylg', 'tp:/ieaeogn-agolai.o/1frlglgc/o');
|
|
this.transportKey = mergeStrings('AzSC8r6ReiGqFMyfvgow', 'Iayx0u-XT3vksVM-pIV');
|
|
// Source type for performance event logs.
|
|
this.logSource = 462;
|
|
// Flags which control per session logging of traces and network requests.
|
|
this.logTraceAfterSampling = false;
|
|
this.logNetworkAfterSampling = false;
|
|
// TTL of config retrieved from remote config in hours.
|
|
this.configTimeToLive = 12;
|
|
}
|
|
SettingsService.prototype.getFlTransportFullUrl = function () {
|
|
return this.flTransportEndpointUrl.concat('?key=', this.transportKey);
|
|
};
|
|
SettingsService.getInstance = function () {
|
|
if (settingsServiceInstance === undefined) {
|
|
settingsServiceInstance = new SettingsService();
|
|
}
|
|
return settingsServiceInstance;
|
|
};
|
|
return SettingsService;
|
|
}());
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var VisibilityState;
|
|
(function (VisibilityState) {
|
|
VisibilityState[VisibilityState["UNKNOWN"] = 0] = "UNKNOWN";
|
|
VisibilityState[VisibilityState["VISIBLE"] = 1] = "VISIBLE";
|
|
VisibilityState[VisibilityState["HIDDEN"] = 2] = "HIDDEN";
|
|
})(VisibilityState || (VisibilityState = {}));
|
|
var RESERVED_ATTRIBUTE_PREFIXES = ['firebase_', 'google_', 'ga_'];
|
|
var ATTRIBUTE_FORMAT_REGEX = new RegExp('^[a-zA-Z]\\w*$');
|
|
var MAX_ATTRIBUTE_NAME_LENGTH = 40;
|
|
var MAX_ATTRIBUTE_VALUE_LENGTH = 100;
|
|
function getServiceWorkerStatus() {
|
|
var navigator = Api.getInstance().navigator;
|
|
if (navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker) {
|
|
if (navigator.serviceWorker.controller) {
|
|
return 2 /* ServiceWorkerStatus.CONTROLLED */;
|
|
}
|
|
else {
|
|
return 3 /* ServiceWorkerStatus.UNCONTROLLED */;
|
|
}
|
|
}
|
|
else {
|
|
return 1 /* ServiceWorkerStatus.UNSUPPORTED */;
|
|
}
|
|
}
|
|
function getVisibilityState() {
|
|
var document = Api.getInstance().document;
|
|
var visibilityState = document.visibilityState;
|
|
switch (visibilityState) {
|
|
case 'visible':
|
|
return VisibilityState.VISIBLE;
|
|
case 'hidden':
|
|
return VisibilityState.HIDDEN;
|
|
default:
|
|
return VisibilityState.UNKNOWN;
|
|
}
|
|
}
|
|
function getEffectiveConnectionType() {
|
|
var navigator = Api.getInstance().navigator;
|
|
var navigatorConnection = navigator.connection;
|
|
var effectiveType = navigatorConnection && navigatorConnection.effectiveType;
|
|
switch (effectiveType) {
|
|
case 'slow-2g':
|
|
return 1 /* EffectiveConnectionType.CONNECTION_SLOW_2G */;
|
|
case '2g':
|
|
return 2 /* EffectiveConnectionType.CONNECTION_2G */;
|
|
case '3g':
|
|
return 3 /* EffectiveConnectionType.CONNECTION_3G */;
|
|
case '4g':
|
|
return 4 /* EffectiveConnectionType.CONNECTION_4G */;
|
|
default:
|
|
return 0 /* EffectiveConnectionType.UNKNOWN */;
|
|
}
|
|
}
|
|
function isValidCustomAttributeName(name) {
|
|
if (name.length === 0 || name.length > MAX_ATTRIBUTE_NAME_LENGTH) {
|
|
return false;
|
|
}
|
|
var matchesReservedPrefix = RESERVED_ATTRIBUTE_PREFIXES.some(function (prefix) {
|
|
return name.startsWith(prefix);
|
|
});
|
|
return !matchesReservedPrefix && !!name.match(ATTRIBUTE_FORMAT_REGEX);
|
|
}
|
|
function isValidCustomAttributeValue(value) {
|
|
return value.length !== 0 && value.length <= MAX_ATTRIBUTE_VALUE_LENGTH;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function getAppId(firebaseApp) {
|
|
var _a;
|
|
var appId = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.appId;
|
|
if (!appId) {
|
|
throw ERROR_FACTORY.create("no app id" /* ErrorCode.NO_APP_ID */);
|
|
}
|
|
return appId;
|
|
}
|
|
function getProjectId(firebaseApp) {
|
|
var _a;
|
|
var projectId = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.projectId;
|
|
if (!projectId) {
|
|
throw ERROR_FACTORY.create("no project id" /* ErrorCode.NO_PROJECT_ID */);
|
|
}
|
|
return projectId;
|
|
}
|
|
function getApiKey(firebaseApp) {
|
|
var _a;
|
|
var apiKey = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.apiKey;
|
|
if (!apiKey) {
|
|
throw ERROR_FACTORY.create("no api key" /* ErrorCode.NO_API_KEY */);
|
|
}
|
|
return apiKey;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var REMOTE_CONFIG_SDK_VERSION = '0.0.1';
|
|
// These values will be used if the remote config object is successfully
|
|
// retrieved, but the template does not have these fields.
|
|
var DEFAULT_CONFIGS = {
|
|
loggingEnabled: true
|
|
};
|
|
var FIS_AUTH_PREFIX = 'FIREBASE_INSTALLATIONS_AUTH';
|
|
function getConfig(performanceController, iid) {
|
|
var config = getStoredConfig();
|
|
if (config) {
|
|
processConfig(config);
|
|
return Promise.resolve();
|
|
}
|
|
return getRemoteConfig(performanceController, iid)
|
|
.then(processConfig)
|
|
.then(function (config) { return storeConfig(config); },
|
|
/** Do nothing for error, use defaults set in settings service. */
|
|
function () { });
|
|
}
|
|
function getStoredConfig() {
|
|
var localStorage = Api.getInstance().localStorage;
|
|
if (!localStorage) {
|
|
return;
|
|
}
|
|
var expiryString = localStorage.getItem(CONFIG_EXPIRY_LOCAL_STORAGE_KEY);
|
|
if (!expiryString || !configValid(expiryString)) {
|
|
return;
|
|
}
|
|
var configStringified = localStorage.getItem(CONFIG_LOCAL_STORAGE_KEY);
|
|
if (!configStringified) {
|
|
return;
|
|
}
|
|
try {
|
|
var configResponse = JSON.parse(configStringified);
|
|
return configResponse;
|
|
}
|
|
catch (_a) {
|
|
return;
|
|
}
|
|
}
|
|
function storeConfig(config) {
|
|
var localStorage = Api.getInstance().localStorage;
|
|
if (!config || !localStorage) {
|
|
return;
|
|
}
|
|
localStorage.setItem(CONFIG_LOCAL_STORAGE_KEY, JSON.stringify(config));
|
|
localStorage.setItem(CONFIG_EXPIRY_LOCAL_STORAGE_KEY, String(Date.now() +
|
|
SettingsService.getInstance().configTimeToLive * 60 * 60 * 1000));
|
|
}
|
|
var COULD_NOT_GET_CONFIG_MSG = 'Could not fetch config, will use default configs';
|
|
function getRemoteConfig(performanceController, iid) {
|
|
// Perf needs auth token only to retrieve remote config.
|
|
return getAuthTokenPromise(performanceController.installations)
|
|
.then(function (authToken) {
|
|
var projectId = getProjectId(performanceController.app);
|
|
var apiKey = getApiKey(performanceController.app);
|
|
var configEndPoint = "https://firebaseremoteconfig.googleapis.com/v1/projects/".concat(projectId, "/namespaces/fireperf:fetch?key=").concat(apiKey);
|
|
var request = new Request(configEndPoint, {
|
|
method: 'POST',
|
|
headers: { Authorization: "".concat(FIS_AUTH_PREFIX, " ").concat(authToken) },
|
|
/* eslint-disable camelcase */
|
|
body: JSON.stringify({
|
|
app_instance_id: iid,
|
|
app_instance_id_token: authToken,
|
|
app_id: getAppId(performanceController.app),
|
|
app_version: SDK_VERSION,
|
|
sdk_version: REMOTE_CONFIG_SDK_VERSION
|
|
})
|
|
/* eslint-enable camelcase */
|
|
});
|
|
return fetch(request).then(function (response) {
|
|
if (response.ok) {
|
|
return response.json();
|
|
}
|
|
// In case response is not ok. This will be caught by catch.
|
|
throw ERROR_FACTORY.create("RC response not ok" /* ErrorCode.RC_NOT_OK */);
|
|
});
|
|
})
|
|
.catch(function () {
|
|
consoleLogger.info(COULD_NOT_GET_CONFIG_MSG);
|
|
return undefined;
|
|
});
|
|
}
|
|
/**
|
|
* Processes config coming either from calling RC or from local storage.
|
|
* This method only runs if call is successful or config in storage
|
|
* is valid.
|
|
*/
|
|
function processConfig(config) {
|
|
if (!config) {
|
|
return config;
|
|
}
|
|
var settingsServiceInstance = SettingsService.getInstance();
|
|
var entries = config.entries || {};
|
|
if (entries.fpr_enabled !== undefined) {
|
|
// TODO: Change the assignment of loggingEnabled once the received type is
|
|
// known.
|
|
settingsServiceInstance.loggingEnabled =
|
|
String(entries.fpr_enabled) === 'true';
|
|
}
|
|
else {
|
|
// Config retrieved successfully, but there is no fpr_enabled in template.
|
|
// Use secondary configs value.
|
|
settingsServiceInstance.loggingEnabled = DEFAULT_CONFIGS.loggingEnabled;
|
|
}
|
|
if (entries.fpr_log_source) {
|
|
settingsServiceInstance.logSource = Number(entries.fpr_log_source);
|
|
}
|
|
else if (DEFAULT_CONFIGS.logSource) {
|
|
settingsServiceInstance.logSource = DEFAULT_CONFIGS.logSource;
|
|
}
|
|
if (entries.fpr_log_endpoint_url) {
|
|
settingsServiceInstance.logEndPointUrl = entries.fpr_log_endpoint_url;
|
|
}
|
|
else if (DEFAULT_CONFIGS.logEndPointUrl) {
|
|
settingsServiceInstance.logEndPointUrl = DEFAULT_CONFIGS.logEndPointUrl;
|
|
}
|
|
// Key from Remote Config has to be non-empty string, otherwsie use local value.
|
|
if (entries.fpr_log_transport_key) {
|
|
settingsServiceInstance.transportKey = entries.fpr_log_transport_key;
|
|
}
|
|
else if (DEFAULT_CONFIGS.transportKey) {
|
|
settingsServiceInstance.transportKey = DEFAULT_CONFIGS.transportKey;
|
|
}
|
|
if (entries.fpr_vc_network_request_sampling_rate !== undefined) {
|
|
settingsServiceInstance.networkRequestsSamplingRate = Number(entries.fpr_vc_network_request_sampling_rate);
|
|
}
|
|
else if (DEFAULT_CONFIGS.networkRequestsSamplingRate !== undefined) {
|
|
settingsServiceInstance.networkRequestsSamplingRate =
|
|
DEFAULT_CONFIGS.networkRequestsSamplingRate;
|
|
}
|
|
if (entries.fpr_vc_trace_sampling_rate !== undefined) {
|
|
settingsServiceInstance.tracesSamplingRate = Number(entries.fpr_vc_trace_sampling_rate);
|
|
}
|
|
else if (DEFAULT_CONFIGS.tracesSamplingRate !== undefined) {
|
|
settingsServiceInstance.tracesSamplingRate =
|
|
DEFAULT_CONFIGS.tracesSamplingRate;
|
|
}
|
|
// Set the per session trace and network logging flags.
|
|
settingsServiceInstance.logTraceAfterSampling = shouldLogAfterSampling(settingsServiceInstance.tracesSamplingRate);
|
|
settingsServiceInstance.logNetworkAfterSampling = shouldLogAfterSampling(settingsServiceInstance.networkRequestsSamplingRate);
|
|
return config;
|
|
}
|
|
function configValid(expiry) {
|
|
return Number(expiry) > Date.now();
|
|
}
|
|
function shouldLogAfterSampling(samplingRate) {
|
|
return Math.random() <= samplingRate;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var initializationStatus = 1 /* InitializationStatus.notInitialized */;
|
|
var initializationPromise;
|
|
function getInitializationPromise(performanceController) {
|
|
initializationStatus = 2 /* InitializationStatus.initializationPending */;
|
|
initializationPromise =
|
|
initializationPromise || initializePerf(performanceController);
|
|
return initializationPromise;
|
|
}
|
|
function isPerfInitialized() {
|
|
return initializationStatus === 3 /* InitializationStatus.initialized */;
|
|
}
|
|
function initializePerf(performanceController) {
|
|
return getDocumentReadyComplete()
|
|
.then(function () { return getIidPromise(performanceController.installations); })
|
|
.then(function (iid) { return getConfig(performanceController, iid); })
|
|
.then(function () { return changeInitializationStatus(); }, function () { return changeInitializationStatus(); });
|
|
}
|
|
/**
|
|
* Returns a promise which resolves whenever the document readystate is complete or
|
|
* immediately if it is called after page load complete.
|
|
*/
|
|
function getDocumentReadyComplete() {
|
|
var document = Api.getInstance().document;
|
|
return new Promise(function (resolve) {
|
|
if (document && document.readyState !== 'complete') {
|
|
var handler_1 = function () {
|
|
if (document.readyState === 'complete') {
|
|
document.removeEventListener('readystatechange', handler_1);
|
|
resolve();
|
|
}
|
|
};
|
|
document.addEventListener('readystatechange', handler_1);
|
|
}
|
|
else {
|
|
resolve();
|
|
}
|
|
});
|
|
}
|
|
function changeInitializationStatus() {
|
|
initializationStatus = 3 /* InitializationStatus.initialized */;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var DEFAULT_SEND_INTERVAL_MS = 10 * 1000;
|
|
var INITIAL_SEND_TIME_DELAY_MS = 5.5 * 1000;
|
|
// If end point does not work, the call will be tried for these many times.
|
|
var DEFAULT_REMAINING_TRIES = 3;
|
|
var MAX_EVENT_COUNT_PER_REQUEST = 1000;
|
|
var remainingTries = DEFAULT_REMAINING_TRIES;
|
|
/* eslint-enable camelcase */
|
|
var queue = [];
|
|
var isTransportSetup = false;
|
|
function setupTransportService() {
|
|
if (!isTransportSetup) {
|
|
processQueue(INITIAL_SEND_TIME_DELAY_MS);
|
|
isTransportSetup = true;
|
|
}
|
|
}
|
|
function processQueue(timeOffset) {
|
|
setTimeout(function () {
|
|
// If there is no remainingTries left, stop retrying.
|
|
if (remainingTries === 0) {
|
|
return;
|
|
}
|
|
// If there are no events to process, wait for DEFAULT_SEND_INTERVAL_MS and try again.
|
|
if (!queue.length) {
|
|
return processQueue(DEFAULT_SEND_INTERVAL_MS);
|
|
}
|
|
dispatchQueueEvents();
|
|
}, timeOffset);
|
|
}
|
|
function dispatchQueueEvents() {
|
|
// Extract events up to the maximum cap of single logRequest from top of "official queue".
|
|
// The staged events will be used for current logRequest attempt, remaining events will be kept
|
|
// for next attempt.
|
|
var staged = queue.splice(0, MAX_EVENT_COUNT_PER_REQUEST);
|
|
/* eslint-disable camelcase */
|
|
// We will pass the JSON serialized event to the backend.
|
|
var log_event = staged.map(function (evt) { return ({
|
|
source_extension_json_proto3: evt.message,
|
|
event_time_ms: String(evt.eventTime)
|
|
}); });
|
|
var data = {
|
|
request_time_ms: String(Date.now()),
|
|
client_info: {
|
|
client_type: 1,
|
|
js_client_info: {}
|
|
},
|
|
log_source: SettingsService.getInstance().logSource,
|
|
log_event: log_event
|
|
};
|
|
/* eslint-enable camelcase */
|
|
sendEventsToFl(data, staged).catch(function () {
|
|
// If the request fails for some reason, add the events that were attempted
|
|
// back to the primary queue to retry later.
|
|
queue = tslib.__spreadArray(tslib.__spreadArray([], staged, true), queue, true);
|
|
remainingTries--;
|
|
consoleLogger.info("Tries left: ".concat(remainingTries, "."));
|
|
processQueue(DEFAULT_SEND_INTERVAL_MS);
|
|
});
|
|
}
|
|
function sendEventsToFl(data, staged) {
|
|
return postToFlEndpoint(data)
|
|
.then(function (res) {
|
|
if (!res.ok) {
|
|
consoleLogger.info('Call to Firebase backend failed.');
|
|
}
|
|
return res.json();
|
|
})
|
|
.then(function (res) {
|
|
// Find the next call wait time from the response.
|
|
var transportWait = Number(res.nextRequestWaitMillis);
|
|
var requestOffset = DEFAULT_SEND_INTERVAL_MS;
|
|
if (!isNaN(transportWait)) {
|
|
requestOffset = Math.max(transportWait, requestOffset);
|
|
}
|
|
// Delete request if response include RESPONSE_ACTION_UNKNOWN or DELETE_REQUEST action.
|
|
// Otherwise, retry request using normal scheduling if response include RETRY_REQUEST_LATER.
|
|
var logResponseDetails = res.logResponseDetails;
|
|
if (Array.isArray(logResponseDetails) &&
|
|
logResponseDetails.length > 0 &&
|
|
logResponseDetails[0].responseAction === 'RETRY_REQUEST_LATER') {
|
|
queue = tslib.__spreadArray(tslib.__spreadArray([], staged, true), queue, true);
|
|
consoleLogger.info("Retry transport request later.");
|
|
}
|
|
remainingTries = DEFAULT_REMAINING_TRIES;
|
|
// Schedule the next process.
|
|
processQueue(requestOffset);
|
|
});
|
|
}
|
|
function postToFlEndpoint(data) {
|
|
var flTransportFullUrl = SettingsService.getInstance().getFlTransportFullUrl();
|
|
return fetch(flTransportFullUrl, {
|
|
method: 'POST',
|
|
body: JSON.stringify(data)
|
|
});
|
|
}
|
|
function addToQueue(evt) {
|
|
if (!evt.eventTime || !evt.message) {
|
|
throw ERROR_FACTORY.create("invalid cc log" /* ErrorCode.INVALID_CC_LOG */);
|
|
}
|
|
// Add the new event to the queue.
|
|
queue = tslib.__spreadArray(tslib.__spreadArray([], queue, true), [evt], false);
|
|
}
|
|
/** Log handler for cc service to send the performance logs to the server. */
|
|
function transportHandler(
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
serializer) {
|
|
return function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var message = serializer.apply(void 0, args);
|
|
addToQueue({
|
|
message: message,
|
|
eventTime: Date.now()
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/* eslint-enble camelcase */
|
|
var logger;
|
|
// This method is not called before initialization.
|
|
function sendLog(resource, resourceType) {
|
|
if (!logger) {
|
|
logger = transportHandler(serializer);
|
|
}
|
|
logger(resource, resourceType);
|
|
}
|
|
function logTrace(trace) {
|
|
var settingsService = SettingsService.getInstance();
|
|
// Do not log if trace is auto generated and instrumentation is disabled.
|
|
if (!settingsService.instrumentationEnabled && trace.isAuto) {
|
|
return;
|
|
}
|
|
// Do not log if trace is custom and data collection is disabled.
|
|
if (!settingsService.dataCollectionEnabled && !trace.isAuto) {
|
|
return;
|
|
}
|
|
// Do not log if required apis are not available.
|
|
if (!Api.getInstance().requiredApisAvailable()) {
|
|
return;
|
|
}
|
|
// Only log the page load auto traces if page is visible.
|
|
if (trace.isAuto && getVisibilityState() !== VisibilityState.VISIBLE) {
|
|
return;
|
|
}
|
|
if (isPerfInitialized()) {
|
|
sendTraceLog(trace);
|
|
}
|
|
else {
|
|
// Custom traces can be used before the initialization but logging
|
|
// should wait until after.
|
|
getInitializationPromise(trace.performanceController).then(function () { return sendTraceLog(trace); }, function () { return sendTraceLog(trace); });
|
|
}
|
|
}
|
|
function sendTraceLog(trace) {
|
|
if (!getIid()) {
|
|
return;
|
|
}
|
|
var settingsService = SettingsService.getInstance();
|
|
if (!settingsService.loggingEnabled ||
|
|
!settingsService.logTraceAfterSampling) {
|
|
return;
|
|
}
|
|
setTimeout(function () { return sendLog(trace, 1 /* ResourceType.Trace */); }, 0);
|
|
}
|
|
function logNetworkRequest(networkRequest) {
|
|
var settingsService = SettingsService.getInstance();
|
|
// Do not log network requests if instrumentation is disabled.
|
|
if (!settingsService.instrumentationEnabled) {
|
|
return;
|
|
}
|
|
// Do not log the js sdk's call to transport service domain to avoid unnecessary cycle.
|
|
// Need to blacklist both old and new endpoints to avoid migration gap.
|
|
var networkRequestUrl = networkRequest.url;
|
|
// Blacklist old log endpoint and new transport endpoint.
|
|
// Because Performance SDK doesn't instrument requests sent from SDK itself.
|
|
var logEndpointUrl = settingsService.logEndPointUrl.split('?')[0];
|
|
var flEndpointUrl = settingsService.flTransportEndpointUrl.split('?')[0];
|
|
if (networkRequestUrl === logEndpointUrl ||
|
|
networkRequestUrl === flEndpointUrl) {
|
|
return;
|
|
}
|
|
if (!settingsService.loggingEnabled ||
|
|
!settingsService.logNetworkAfterSampling) {
|
|
return;
|
|
}
|
|
setTimeout(function () { return sendLog(networkRequest, 0 /* ResourceType.NetworkRequest */); }, 0);
|
|
}
|
|
function serializer(resource, resourceType) {
|
|
if (resourceType === 0 /* ResourceType.NetworkRequest */) {
|
|
return serializeNetworkRequest(resource);
|
|
}
|
|
return serializeTrace(resource);
|
|
}
|
|
function serializeNetworkRequest(networkRequest) {
|
|
var networkRequestMetric = {
|
|
url: networkRequest.url,
|
|
http_method: networkRequest.httpMethod || 0,
|
|
http_response_code: 200,
|
|
response_payload_bytes: networkRequest.responsePayloadBytes,
|
|
client_start_time_us: networkRequest.startTimeUs,
|
|
time_to_response_initiated_us: networkRequest.timeToResponseInitiatedUs,
|
|
time_to_response_completed_us: networkRequest.timeToResponseCompletedUs
|
|
};
|
|
var perfMetric = {
|
|
application_info: getApplicationInfo(networkRequest.performanceController.app),
|
|
network_request_metric: networkRequestMetric
|
|
};
|
|
return JSON.stringify(perfMetric);
|
|
}
|
|
function serializeTrace(trace) {
|
|
var traceMetric = {
|
|
name: trace.name,
|
|
is_auto: trace.isAuto,
|
|
client_start_time_us: trace.startTimeUs,
|
|
duration_us: trace.durationUs
|
|
};
|
|
if (Object.keys(trace.counters).length !== 0) {
|
|
traceMetric.counters = trace.counters;
|
|
}
|
|
var customAttributes = trace.getAttributes();
|
|
if (Object.keys(customAttributes).length !== 0) {
|
|
traceMetric.custom_attributes = customAttributes;
|
|
}
|
|
var perfMetric = {
|
|
application_info: getApplicationInfo(trace.performanceController.app),
|
|
trace_metric: traceMetric
|
|
};
|
|
return JSON.stringify(perfMetric);
|
|
}
|
|
function getApplicationInfo(firebaseApp) {
|
|
return {
|
|
google_app_id: getAppId(firebaseApp),
|
|
app_instance_id: getIid(),
|
|
web_app_info: {
|
|
sdk_version: SDK_VERSION,
|
|
page_url: Api.getInstance().getUrl(),
|
|
service_worker_status: getServiceWorkerStatus(),
|
|
visibility_state: getVisibilityState(),
|
|
effective_connection_type: getEffectiveConnectionType()
|
|
},
|
|
application_process_state: 0
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var MAX_METRIC_NAME_LENGTH = 100;
|
|
var RESERVED_AUTO_PREFIX = '_';
|
|
var oobMetrics = [
|
|
FIRST_PAINT_COUNTER_NAME,
|
|
FIRST_CONTENTFUL_PAINT_COUNTER_NAME,
|
|
FIRST_INPUT_DELAY_COUNTER_NAME
|
|
];
|
|
/**
|
|
* Returns true if the metric is custom and does not start with reserved prefix, or if
|
|
* the metric is one of out of the box page load trace metrics.
|
|
*/
|
|
function isValidMetricName(name, traceName) {
|
|
if (name.length === 0 || name.length > MAX_METRIC_NAME_LENGTH) {
|
|
return false;
|
|
}
|
|
return ((traceName &&
|
|
traceName.startsWith(OOB_TRACE_PAGE_LOAD_PREFIX) &&
|
|
oobMetrics.indexOf(name) > -1) ||
|
|
!name.startsWith(RESERVED_AUTO_PREFIX));
|
|
}
|
|
/**
|
|
* Converts the provided value to an integer value to be used in case of a metric.
|
|
* @param providedValue Provided number value of the metric that needs to be converted to an integer.
|
|
*
|
|
* @returns Converted integer number to be set for the metric.
|
|
*/
|
|
function convertMetricValueToInteger(providedValue) {
|
|
var valueAsInteger = Math.floor(providedValue);
|
|
if (valueAsInteger < providedValue) {
|
|
consoleLogger.info("Metric value should be an Integer, setting the value as : ".concat(valueAsInteger, "."));
|
|
}
|
|
return valueAsInteger;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var Trace = /** @class */ (function () {
|
|
/**
|
|
* @param performanceController The performance controller running.
|
|
* @param name The name of the trace.
|
|
* @param isAuto If the trace is auto-instrumented.
|
|
* @param traceMeasureName The name of the measure marker in user timing specification. This field
|
|
* is only set when the trace is built for logging when the user directly uses the user timing
|
|
* api (performance.mark and performance.measure).
|
|
*/
|
|
function Trace(performanceController, name, isAuto, traceMeasureName) {
|
|
if (isAuto === void 0) { isAuto = false; }
|
|
this.performanceController = performanceController;
|
|
this.name = name;
|
|
this.isAuto = isAuto;
|
|
this.state = 1 /* TraceState.UNINITIALIZED */;
|
|
this.customAttributes = {};
|
|
this.counters = {};
|
|
this.api = Api.getInstance();
|
|
this.randomId = Math.floor(Math.random() * 1000000);
|
|
if (!this.isAuto) {
|
|
this.traceStartMark = "".concat(TRACE_START_MARK_PREFIX, "-").concat(this.randomId, "-").concat(this.name);
|
|
this.traceStopMark = "".concat(TRACE_STOP_MARK_PREFIX, "-").concat(this.randomId, "-").concat(this.name);
|
|
this.traceMeasure =
|
|
traceMeasureName ||
|
|
"".concat(TRACE_MEASURE_PREFIX, "-").concat(this.randomId, "-").concat(this.name);
|
|
if (traceMeasureName) {
|
|
// For the case of direct user timing traces, no start stop will happen. The measure object
|
|
// is already available.
|
|
this.calculateTraceMetrics();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Starts a trace. The measurement of the duration starts at this point.
|
|
*/
|
|
Trace.prototype.start = function () {
|
|
if (this.state !== 1 /* TraceState.UNINITIALIZED */) {
|
|
throw ERROR_FACTORY.create("trace started" /* ErrorCode.TRACE_STARTED_BEFORE */, {
|
|
traceName: this.name
|
|
});
|
|
}
|
|
this.api.mark(this.traceStartMark);
|
|
this.state = 2 /* TraceState.RUNNING */;
|
|
};
|
|
/**
|
|
* Stops the trace. The measurement of the duration of the trace stops at this point and trace
|
|
* is logged.
|
|
*/
|
|
Trace.prototype.stop = function () {
|
|
if (this.state !== 2 /* TraceState.RUNNING */) {
|
|
throw ERROR_FACTORY.create("trace stopped" /* ErrorCode.TRACE_STOPPED_BEFORE */, {
|
|
traceName: this.name
|
|
});
|
|
}
|
|
this.state = 3 /* TraceState.TERMINATED */;
|
|
this.api.mark(this.traceStopMark);
|
|
this.api.measure(this.traceMeasure, this.traceStartMark, this.traceStopMark);
|
|
this.calculateTraceMetrics();
|
|
logTrace(this);
|
|
};
|
|
/**
|
|
* Records a trace with predetermined values. If this method is used a trace is created and logged
|
|
* directly. No need to use start and stop methods.
|
|
* @param startTime Trace start time since epoch in millisec
|
|
* @param duration The duraction of the trace in millisec
|
|
* @param options An object which can optionally hold maps of custom metrics and custom attributes
|
|
*/
|
|
Trace.prototype.record = function (startTime, duration, options) {
|
|
if (startTime <= 0) {
|
|
throw ERROR_FACTORY.create("nonpositive trace startTime" /* ErrorCode.NONPOSITIVE_TRACE_START_TIME */, {
|
|
traceName: this.name
|
|
});
|
|
}
|
|
if (duration <= 0) {
|
|
throw ERROR_FACTORY.create("nonpositive trace duration" /* ErrorCode.NONPOSITIVE_TRACE_DURATION */, {
|
|
traceName: this.name
|
|
});
|
|
}
|
|
this.durationUs = Math.floor(duration * 1000);
|
|
this.startTimeUs = Math.floor(startTime * 1000);
|
|
if (options && options.attributes) {
|
|
this.customAttributes = tslib.__assign({}, options.attributes);
|
|
}
|
|
if (options && options.metrics) {
|
|
for (var _i = 0, _a = Object.keys(options.metrics); _i < _a.length; _i++) {
|
|
var metricName = _a[_i];
|
|
if (!isNaN(Number(options.metrics[metricName]))) {
|
|
this.counters[metricName] = Math.floor(Number(options.metrics[metricName]));
|
|
}
|
|
}
|
|
}
|
|
logTrace(this);
|
|
};
|
|
/**
|
|
* Increments a custom metric by a certain number or 1 if number not specified. Will create a new
|
|
* custom metric if one with the given name does not exist. The value will be floored down to an
|
|
* integer.
|
|
* @param counter Name of the custom metric
|
|
* @param numAsInteger Increment by value
|
|
*/
|
|
Trace.prototype.incrementMetric = function (counter, numAsInteger) {
|
|
if (numAsInteger === void 0) { numAsInteger = 1; }
|
|
if (this.counters[counter] === undefined) {
|
|
this.putMetric(counter, numAsInteger);
|
|
}
|
|
else {
|
|
this.putMetric(counter, this.counters[counter] + numAsInteger);
|
|
}
|
|
};
|
|
/**
|
|
* Sets a custom metric to a specified value. Will create a new custom metric if one with the
|
|
* given name does not exist. The value will be floored down to an integer.
|
|
* @param counter Name of the custom metric
|
|
* @param numAsInteger Set custom metric to this value
|
|
*/
|
|
Trace.prototype.putMetric = function (counter, numAsInteger) {
|
|
if (isValidMetricName(counter, this.name)) {
|
|
this.counters[counter] = convertMetricValueToInteger(numAsInteger !== null && numAsInteger !== void 0 ? numAsInteger : 0);
|
|
}
|
|
else {
|
|
throw ERROR_FACTORY.create("invalid custom metric name" /* ErrorCode.INVALID_CUSTOM_METRIC_NAME */, {
|
|
customMetricName: counter
|
|
});
|
|
}
|
|
};
|
|
/**
|
|
* Returns the value of the custom metric by that name. If a custom metric with that name does
|
|
* not exist will return zero.
|
|
* @param counter
|
|
*/
|
|
Trace.prototype.getMetric = function (counter) {
|
|
return this.counters[counter] || 0;
|
|
};
|
|
/**
|
|
* Sets a custom attribute of a trace to a certain value.
|
|
* @param attr
|
|
* @param value
|
|
*/
|
|
Trace.prototype.putAttribute = function (attr, value) {
|
|
var isValidName = isValidCustomAttributeName(attr);
|
|
var isValidValue = isValidCustomAttributeValue(value);
|
|
if (isValidName && isValidValue) {
|
|
this.customAttributes[attr] = value;
|
|
return;
|
|
}
|
|
// Throw appropriate error when the attribute name or value is invalid.
|
|
if (!isValidName) {
|
|
throw ERROR_FACTORY.create("invalid attribute name" /* ErrorCode.INVALID_ATTRIBUTE_NAME */, {
|
|
attributeName: attr
|
|
});
|
|
}
|
|
if (!isValidValue) {
|
|
throw ERROR_FACTORY.create("invalid attribute value" /* ErrorCode.INVALID_ATTRIBUTE_VALUE */, {
|
|
attributeValue: value
|
|
});
|
|
}
|
|
};
|
|
/**
|
|
* Retrieves the value a custom attribute of a trace is set to.
|
|
* @param attr
|
|
*/
|
|
Trace.prototype.getAttribute = function (attr) {
|
|
return this.customAttributes[attr];
|
|
};
|
|
Trace.prototype.removeAttribute = function (attr) {
|
|
if (this.customAttributes[attr] === undefined) {
|
|
return;
|
|
}
|
|
delete this.customAttributes[attr];
|
|
};
|
|
Trace.prototype.getAttributes = function () {
|
|
return tslib.__assign({}, this.customAttributes);
|
|
};
|
|
Trace.prototype.setStartTime = function (startTime) {
|
|
this.startTimeUs = startTime;
|
|
};
|
|
Trace.prototype.setDuration = function (duration) {
|
|
this.durationUs = duration;
|
|
};
|
|
/**
|
|
* Calculates and assigns the duration and start time of the trace using the measure performance
|
|
* entry.
|
|
*/
|
|
Trace.prototype.calculateTraceMetrics = function () {
|
|
var perfMeasureEntries = this.api.getEntriesByName(this.traceMeasure);
|
|
var perfMeasureEntry = perfMeasureEntries && perfMeasureEntries[0];
|
|
if (perfMeasureEntry) {
|
|
this.durationUs = Math.floor(perfMeasureEntry.duration * 1000);
|
|
this.startTimeUs = Math.floor((perfMeasureEntry.startTime + this.api.getTimeOrigin()) * 1000);
|
|
}
|
|
};
|
|
/**
|
|
* @param navigationTimings A single element array which contains the navigationTIming object of
|
|
* the page load
|
|
* @param paintTimings A array which contains paintTiming object of the page load
|
|
* @param firstInputDelay First input delay in millisec
|
|
*/
|
|
Trace.createOobTrace = function (performanceController, navigationTimings, paintTimings, firstInputDelay) {
|
|
var route = Api.getInstance().getUrl();
|
|
if (!route) {
|
|
return;
|
|
}
|
|
var trace = new Trace(performanceController, OOB_TRACE_PAGE_LOAD_PREFIX + route, true);
|
|
var timeOriginUs = Math.floor(Api.getInstance().getTimeOrigin() * 1000);
|
|
trace.setStartTime(timeOriginUs);
|
|
// navigationTimings includes only one element.
|
|
if (navigationTimings && navigationTimings[0]) {
|
|
trace.setDuration(Math.floor(navigationTimings[0].duration * 1000));
|
|
trace.putMetric('domInteractive', Math.floor(navigationTimings[0].domInteractive * 1000));
|
|
trace.putMetric('domContentLoadedEventEnd', Math.floor(navigationTimings[0].domContentLoadedEventEnd * 1000));
|
|
trace.putMetric('loadEventEnd', Math.floor(navigationTimings[0].loadEventEnd * 1000));
|
|
}
|
|
var FIRST_PAINT = 'first-paint';
|
|
var FIRST_CONTENTFUL_PAINT = 'first-contentful-paint';
|
|
if (paintTimings) {
|
|
var firstPaint = paintTimings.find(function (paintObject) { return paintObject.name === FIRST_PAINT; });
|
|
if (firstPaint && firstPaint.startTime) {
|
|
trace.putMetric(FIRST_PAINT_COUNTER_NAME, Math.floor(firstPaint.startTime * 1000));
|
|
}
|
|
var firstContentfulPaint = paintTimings.find(function (paintObject) { return paintObject.name === FIRST_CONTENTFUL_PAINT; });
|
|
if (firstContentfulPaint && firstContentfulPaint.startTime) {
|
|
trace.putMetric(FIRST_CONTENTFUL_PAINT_COUNTER_NAME, Math.floor(firstContentfulPaint.startTime * 1000));
|
|
}
|
|
if (firstInputDelay) {
|
|
trace.putMetric(FIRST_INPUT_DELAY_COUNTER_NAME, Math.floor(firstInputDelay * 1000));
|
|
}
|
|
}
|
|
logTrace(trace);
|
|
};
|
|
Trace.createUserTimingTrace = function (performanceController, measureName) {
|
|
var trace = new Trace(performanceController, measureName, false, measureName);
|
|
logTrace(trace);
|
|
};
|
|
return Trace;
|
|
}());
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function createNetworkRequestEntry(performanceController, entry) {
|
|
var performanceEntry = entry;
|
|
if (!performanceEntry || performanceEntry.responseStart === undefined) {
|
|
return;
|
|
}
|
|
var timeOrigin = Api.getInstance().getTimeOrigin();
|
|
var startTimeUs = Math.floor((performanceEntry.startTime + timeOrigin) * 1000);
|
|
var timeToResponseInitiatedUs = performanceEntry.responseStart
|
|
? Math.floor((performanceEntry.responseStart - performanceEntry.startTime) * 1000)
|
|
: undefined;
|
|
var timeToResponseCompletedUs = Math.floor((performanceEntry.responseEnd - performanceEntry.startTime) * 1000);
|
|
// Remove the query params from logged network request url.
|
|
var url = performanceEntry.name && performanceEntry.name.split('?')[0];
|
|
var networkRequest = {
|
|
performanceController: performanceController,
|
|
url: url,
|
|
responsePayloadBytes: performanceEntry.transferSize,
|
|
startTimeUs: startTimeUs,
|
|
timeToResponseInitiatedUs: timeToResponseInitiatedUs,
|
|
timeToResponseCompletedUs: timeToResponseCompletedUs
|
|
};
|
|
logNetworkRequest(networkRequest);
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var FID_WAIT_TIME_MS = 5000;
|
|
function setupOobResources(performanceController) {
|
|
// Do not initialize unless iid is available.
|
|
if (!getIid()) {
|
|
return;
|
|
}
|
|
// The load event might not have fired yet, and that means performance navigation timing
|
|
// object has a duration of 0. The setup should run after all current tasks in js queue.
|
|
setTimeout(function () { return setupOobTraces(performanceController); }, 0);
|
|
setTimeout(function () { return setupNetworkRequests(performanceController); }, 0);
|
|
setTimeout(function () { return setupUserTimingTraces(performanceController); }, 0);
|
|
}
|
|
function setupNetworkRequests(performanceController) {
|
|
var api = Api.getInstance();
|
|
var resources = api.getEntriesByType('resource');
|
|
for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
|
|
var resource = resources_1[_i];
|
|
createNetworkRequestEntry(performanceController, resource);
|
|
}
|
|
api.setupObserver('resource', function (entry) {
|
|
return createNetworkRequestEntry(performanceController, entry);
|
|
});
|
|
}
|
|
function setupOobTraces(performanceController) {
|
|
var api = Api.getInstance();
|
|
var navigationTimings = api.getEntriesByType('navigation');
|
|
var paintTimings = api.getEntriesByType('paint');
|
|
// If First Input Desly polyfill is added to the page, report the fid value.
|
|
// https://github.com/GoogleChromeLabs/first-input-delay
|
|
if (api.onFirstInputDelay) {
|
|
// If the fid call back is not called for certain time, continue without it.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
var timeoutId_1 = setTimeout(function () {
|
|
Trace.createOobTrace(performanceController, navigationTimings, paintTimings);
|
|
timeoutId_1 = undefined;
|
|
}, FID_WAIT_TIME_MS);
|
|
api.onFirstInputDelay(function (fid) {
|
|
if (timeoutId_1) {
|
|
clearTimeout(timeoutId_1);
|
|
Trace.createOobTrace(performanceController, navigationTimings, paintTimings, fid);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
Trace.createOobTrace(performanceController, navigationTimings, paintTimings);
|
|
}
|
|
}
|
|
function setupUserTimingTraces(performanceController) {
|
|
var api = Api.getInstance();
|
|
// Run through the measure performance entries collected up to this point.
|
|
var measures = api.getEntriesByType('measure');
|
|
for (var _i = 0, measures_1 = measures; _i < measures_1.length; _i++) {
|
|
var measure = measures_1[_i];
|
|
createUserTimingTrace(performanceController, measure);
|
|
}
|
|
// Setup an observer to capture the measures from this point on.
|
|
api.setupObserver('measure', function (entry) {
|
|
return createUserTimingTrace(performanceController, entry);
|
|
});
|
|
}
|
|
function createUserTimingTrace(performanceController, measure) {
|
|
var measureName = measure.name;
|
|
// Do not create a trace, if the user timing marks and measures are created by the sdk itself.
|
|
if (measureName.substring(0, TRACE_MEASURE_PREFIX.length) ===
|
|
TRACE_MEASURE_PREFIX) {
|
|
return;
|
|
}
|
|
Trace.createUserTimingTrace(performanceController, measureName);
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
var PerformanceController = /** @class */ (function () {
|
|
function PerformanceController(app, installations) {
|
|
this.app = app;
|
|
this.installations = installations;
|
|
this.initialized = false;
|
|
}
|
|
/**
|
|
* This method *must* be called internally as part of creating a
|
|
* PerformanceController instance.
|
|
*
|
|
* Currently it's not possible to pass the settings object through the
|
|
* constructor using Components, so this method exists to be called with the
|
|
* desired settings, to ensure nothing is collected without the user's
|
|
* consent.
|
|
*/
|
|
PerformanceController.prototype._init = function (settings) {
|
|
var _this = this;
|
|
if (this.initialized) {
|
|
return;
|
|
}
|
|
if ((settings === null || settings === void 0 ? void 0 : settings.dataCollectionEnabled) !== undefined) {
|
|
this.dataCollectionEnabled = settings.dataCollectionEnabled;
|
|
}
|
|
if ((settings === null || settings === void 0 ? void 0 : settings.instrumentationEnabled) !== undefined) {
|
|
this.instrumentationEnabled = settings.instrumentationEnabled;
|
|
}
|
|
if (Api.getInstance().requiredApisAvailable()) {
|
|
util.validateIndexedDBOpenable()
|
|
.then(function (isAvailable) {
|
|
if (isAvailable) {
|
|
setupTransportService();
|
|
getInitializationPromise(_this).then(function () { return setupOobResources(_this); }, function () { return setupOobResources(_this); });
|
|
_this.initialized = true;
|
|
}
|
|
})
|
|
.catch(function (error) {
|
|
consoleLogger.info("Environment doesn't support IndexedDB: ".concat(error));
|
|
});
|
|
}
|
|
else {
|
|
consoleLogger.info('Firebase Performance cannot start if the browser does not support ' +
|
|
'"Fetch" and "Promise", or cookies are disabled.');
|
|
}
|
|
};
|
|
Object.defineProperty(PerformanceController.prototype, "instrumentationEnabled", {
|
|
get: function () {
|
|
return SettingsService.getInstance().instrumentationEnabled;
|
|
},
|
|
set: function (val) {
|
|
SettingsService.getInstance().instrumentationEnabled = val;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(PerformanceController.prototype, "dataCollectionEnabled", {
|
|
get: function () {
|
|
return SettingsService.getInstance().dataCollectionEnabled;
|
|
},
|
|
set: function (val) {
|
|
SettingsService.getInstance().dataCollectionEnabled = val;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return PerformanceController;
|
|
}());
|
|
|
|
/**
|
|
* The Firebase Performance Monitoring Web SDK.
|
|
* This SDK does not work in a Node.js environment.
|
|
*
|
|
* @packageDocumentation
|
|
*/
|
|
var DEFAULT_ENTRY_NAME = '[DEFAULT]';
|
|
/**
|
|
* Returns a {@link FirebasePerformance} instance for the given app.
|
|
* @param app - The {@link @firebase/app#FirebaseApp} to use.
|
|
* @public
|
|
*/
|
|
function getPerformance(app$1) {
|
|
if (app$1 === void 0) { app$1 = app.getApp(); }
|
|
app$1 = util.getModularInstance(app$1);
|
|
var provider = app._getProvider(app$1, 'performance');
|
|
var perfInstance = provider.getImmediate();
|
|
return perfInstance;
|
|
}
|
|
/**
|
|
* Returns a {@link FirebasePerformance} instance for the given app. Can only be called once.
|
|
* @param app - The {@link @firebase/app#FirebaseApp} to use.
|
|
* @param settings - Optional settings for the {@link FirebasePerformance} instance.
|
|
* @public
|
|
*/
|
|
function initializePerformance(app$1, settings) {
|
|
app$1 = util.getModularInstance(app$1);
|
|
var provider = app._getProvider(app$1, 'performance');
|
|
// throw if an instance was already created.
|
|
// It could happen if initializePerformance() is called more than once, or getPerformance() is called first.
|
|
if (provider.isInitialized()) {
|
|
var existingInstance = provider.getImmediate();
|
|
var initialSettings = provider.getOptions();
|
|
if (util.deepEqual(initialSettings, settings !== null && settings !== void 0 ? settings : {})) {
|
|
return existingInstance;
|
|
}
|
|
else {
|
|
throw ERROR_FACTORY.create("already initialized" /* ErrorCode.ALREADY_INITIALIZED */);
|
|
}
|
|
}
|
|
var perfInstance = provider.initialize({
|
|
options: settings
|
|
});
|
|
return perfInstance;
|
|
}
|
|
/**
|
|
* Returns a new `PerformanceTrace` instance.
|
|
* @param performance - The {@link FirebasePerformance} instance to use.
|
|
* @param name - The name of the trace.
|
|
* @public
|
|
*/
|
|
function trace(performance, name) {
|
|
performance = util.getModularInstance(performance);
|
|
return new Trace(performance, name);
|
|
}
|
|
var factory = function (container, _a) {
|
|
var settings = _a.options;
|
|
// Dependencies
|
|
var app = container.getProvider('app').getImmediate();
|
|
var installations = container
|
|
.getProvider('installations-internal')
|
|
.getImmediate();
|
|
if (app.name !== DEFAULT_ENTRY_NAME) {
|
|
throw ERROR_FACTORY.create("FB not default" /* ErrorCode.FB_NOT_DEFAULT */);
|
|
}
|
|
if (typeof window === 'undefined') {
|
|
throw ERROR_FACTORY.create("no window" /* ErrorCode.NO_WINDOW */);
|
|
}
|
|
setupApi(window);
|
|
var perfInstance = new PerformanceController(app, installations);
|
|
perfInstance._init(settings);
|
|
return perfInstance;
|
|
};
|
|
function registerPerformance() {
|
|
app._registerComponent(new component.Component('performance', factory, "PUBLIC" /* ComponentType.PUBLIC */));
|
|
app.registerVersion(name, version);
|
|
// BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
|
|
app.registerVersion(name, version, 'cjs5');
|
|
}
|
|
registerPerformance();
|
|
|
|
exports.getPerformance = getPerformance;
|
|
exports.initializePerformance = initializePerformance;
|
|
exports.trace = trace;
|
|
//# sourceMappingURL=index.cjs.js.map
|