267 lines
9.6 KiB
JavaScript
267 lines
9.6 KiB
JavaScript
import { __spreadArray } from 'tslib';
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 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;
|
|
/**
|
|
* A container for all of the Logger instances
|
|
*/
|
|
var instances = [];
|
|
/**
|
|
* The JS SDK supports 5 log levels and also allows a user the ability to
|
|
* silence the logs altogether.
|
|
*
|
|
* The order is a follows:
|
|
* DEBUG < VERBOSE < INFO < WARN < ERROR
|
|
*
|
|
* All of the log types above the current log level will be captured (i.e. if
|
|
* you set the log level to `INFO`, errors will still be logged, but `DEBUG` and
|
|
* `VERBOSE` logs will not)
|
|
*/
|
|
var LogLevel;
|
|
(function (LogLevel) {
|
|
LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
|
|
LogLevel[LogLevel["VERBOSE"] = 1] = "VERBOSE";
|
|
LogLevel[LogLevel["INFO"] = 2] = "INFO";
|
|
LogLevel[LogLevel["WARN"] = 3] = "WARN";
|
|
LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
|
|
LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
|
|
})(LogLevel || (LogLevel = {}));
|
|
var levelStringToEnum = {
|
|
'debug': LogLevel.DEBUG,
|
|
'verbose': LogLevel.VERBOSE,
|
|
'info': LogLevel.INFO,
|
|
'warn': LogLevel.WARN,
|
|
'error': LogLevel.ERROR,
|
|
'silent': LogLevel.SILENT
|
|
};
|
|
/**
|
|
* The default log level
|
|
*/
|
|
var defaultLogLevel = LogLevel.INFO;
|
|
/**
|
|
* By default, `console.debug` is not displayed in the developer console (in
|
|
* chrome). To avoid forcing users to have to opt-in to these logs twice
|
|
* (i.e. once for firebase, and once in the console), we are sending `DEBUG`
|
|
* logs to the `console.log` function.
|
|
*/
|
|
var ConsoleMethod = (_a = {},
|
|
_a[LogLevel.DEBUG] = 'log',
|
|
_a[LogLevel.VERBOSE] = 'log',
|
|
_a[LogLevel.INFO] = 'info',
|
|
_a[LogLevel.WARN] = 'warn',
|
|
_a[LogLevel.ERROR] = 'error',
|
|
_a);
|
|
/**
|
|
* The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR
|
|
* messages on to their corresponding console counterparts (if the log method
|
|
* is supported by the current log level)
|
|
*/
|
|
var defaultLogHandler = function (instance, logType) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
if (logType < instance.logLevel) {
|
|
return;
|
|
}
|
|
var now = new Date().toISOString();
|
|
var method = ConsoleMethod[logType];
|
|
if (method) {
|
|
console[method].apply(console, __spreadArray(["[".concat(now, "] ").concat(instance.name, ":")], args, false));
|
|
}
|
|
else {
|
|
throw new Error("Attempted to log a message with an invalid logType (value: ".concat(logType, ")"));
|
|
}
|
|
};
|
|
var Logger = /** @class */ (function () {
|
|
/**
|
|
* Gives you an instance of a Logger to capture messages according to
|
|
* Firebase's logging scheme.
|
|
*
|
|
* @param name The name that the logs will be associated with
|
|
*/
|
|
function Logger(name) {
|
|
this.name = name;
|
|
/**
|
|
* The log level of the given Logger instance.
|
|
*/
|
|
this._logLevel = defaultLogLevel;
|
|
/**
|
|
* The main (internal) log handler for the Logger instance.
|
|
* Can be set to a new function in internal package code but not by user.
|
|
*/
|
|
this._logHandler = defaultLogHandler;
|
|
/**
|
|
* The optional, additional, user-defined log handler for the Logger instance.
|
|
*/
|
|
this._userLogHandler = null;
|
|
/**
|
|
* Capture the current instance for later use
|
|
*/
|
|
instances.push(this);
|
|
}
|
|
Object.defineProperty(Logger.prototype, "logLevel", {
|
|
get: function () {
|
|
return this._logLevel;
|
|
},
|
|
set: function (val) {
|
|
if (!(val in LogLevel)) {
|
|
throw new TypeError("Invalid value \"".concat(val, "\" assigned to `logLevel`"));
|
|
}
|
|
this._logLevel = val;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
// Workaround for setter/getter having to be the same type.
|
|
Logger.prototype.setLogLevel = function (val) {
|
|
this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;
|
|
};
|
|
Object.defineProperty(Logger.prototype, "logHandler", {
|
|
get: function () {
|
|
return this._logHandler;
|
|
},
|
|
set: function (val) {
|
|
if (typeof val !== 'function') {
|
|
throw new TypeError('Value assigned to `logHandler` must be a function');
|
|
}
|
|
this._logHandler = val;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Logger.prototype, "userLogHandler", {
|
|
get: function () {
|
|
return this._userLogHandler;
|
|
},
|
|
set: function (val) {
|
|
this._userLogHandler = val;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* The functions below are all based on the `console` interface
|
|
*/
|
|
Logger.prototype.debug = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.DEBUG], args, false));
|
|
this._logHandler.apply(this, __spreadArray([this, LogLevel.DEBUG], args, false));
|
|
};
|
|
Logger.prototype.log = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.VERBOSE], args, false));
|
|
this._logHandler.apply(this, __spreadArray([this, LogLevel.VERBOSE], args, false));
|
|
};
|
|
Logger.prototype.info = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.INFO], args, false));
|
|
this._logHandler.apply(this, __spreadArray([this, LogLevel.INFO], args, false));
|
|
};
|
|
Logger.prototype.warn = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.WARN], args, false));
|
|
this._logHandler.apply(this, __spreadArray([this, LogLevel.WARN], args, false));
|
|
};
|
|
Logger.prototype.error = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
this._userLogHandler && this._userLogHandler.apply(this, __spreadArray([this, LogLevel.ERROR], args, false));
|
|
this._logHandler.apply(this, __spreadArray([this, LogLevel.ERROR], args, false));
|
|
};
|
|
return Logger;
|
|
}());
|
|
function setLogLevel(level) {
|
|
instances.forEach(function (inst) {
|
|
inst.setLogLevel(level);
|
|
});
|
|
}
|
|
function setUserLogHandler(logCallback, options) {
|
|
var _loop_1 = function (instance) {
|
|
var customLogLevel = null;
|
|
if (options && options.level) {
|
|
customLogLevel = levelStringToEnum[options.level];
|
|
}
|
|
if (logCallback === null) {
|
|
instance.userLogHandler = null;
|
|
}
|
|
else {
|
|
instance.userLogHandler = function (instance, level) {
|
|
var args = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
args[_i - 2] = arguments[_i];
|
|
}
|
|
var message = args
|
|
.map(function (arg) {
|
|
if (arg == null) {
|
|
return null;
|
|
}
|
|
else if (typeof arg === 'string') {
|
|
return arg;
|
|
}
|
|
else if (typeof arg === 'number' || typeof arg === 'boolean') {
|
|
return arg.toString();
|
|
}
|
|
else if (arg instanceof Error) {
|
|
return arg.message;
|
|
}
|
|
else {
|
|
try {
|
|
return JSON.stringify(arg);
|
|
}
|
|
catch (ignored) {
|
|
return null;
|
|
}
|
|
}
|
|
})
|
|
.filter(function (arg) { return arg; })
|
|
.join(' ');
|
|
if (level >= (customLogLevel !== null && customLogLevel !== void 0 ? customLogLevel : instance.logLevel)) {
|
|
logCallback({
|
|
level: LogLevel[level].toLowerCase(),
|
|
message: message,
|
|
args: args,
|
|
type: instance.name
|
|
});
|
|
}
|
|
};
|
|
}
|
|
};
|
|
for (var _i = 0, instances_1 = instances; _i < instances_1.length; _i++) {
|
|
var instance = instances_1[_i];
|
|
_loop_1(instance);
|
|
}
|
|
}
|
|
|
|
export { LogLevel, Logger, setLogLevel, setUserLogHandler };
|
|
//# sourceMappingURL=index.esm5.js.map
|