@hsui/sdk
Version:
Hundsun frontend framework JSSDK
968 lines (943 loc) • 42.5 kB
JavaScript
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
import _createClass from "@babel/runtime/helpers/esm/createClass";
import _inherits from "@babel/runtime/helpers/esm/inherits";
import _createSuper from "@babel/runtime/helpers/esm/createSuper";
/**
* import { createLogger } from "@hsui/sdk";
* const loggerInstance = createLogger();
设置实例日志级别 'debug', 'info', 'warn', 'error'
loggerInstance.setLevel('warn');
loggerInstance.info("日志格式化 11111111111111");
日志只支持字符串格式，对象等需要处理好之后传进来
*/
import SuperClassLogLevel, { createLogger as huiCreateLogger } from '@hsui/logger';
import * as sm4 from './utils/crypto-sm4';
import { isUcf } from './utils/platform';
var KEY = '20220923huisdk344444';
var huiLogger = huiCreateLogger();
export var LogLevel = /*#__PURE__*/function (_SuperClassLogLevel) {
_inherits(LogLevel, _SuperClassLogLevel);
var _super = _createSuper(LogLevel);
function LogLevel() {
var _this;
var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, LogLevel);
_this = _super.call(this);
// 默认埋点级别为 info
// 表名，在需要新建表时动态生成
_this.sheetname = null;
// 是否通过 console 打印
_this.enableConsole = true;
// 是否开启 indexdb 日志存储功能
_this.enableLogIndexDB = data.enableLogIndexDB === true ? true : false;
// 是否在 ucf 客户端
_this.isUcf = isUcf();
// 最大有效表数量
_this.maxSheetCount = data.maxSheetCount || 15;
// 单表最多插入数据条数
_this.maxSheetItemCount = data.maxSheetItemCount || 50000;
// 本地日志过期时间，以天为单位
_this.expiredDays = data.expiredDays || 7;
// 本地日志内容是否加密
_this.encryption = data.encryption === false ? false : true;
_this._indexdb = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
if (!_this.isUcf && !_this._indexdb) {
huiLogger.debug('当前浏览器不支持 indexedDB,日志采集功能暂停使用。');
}
_this._init();
return _this;
}
_createClass(LogLevel, [{
key: "_init",
value: function () {
var _init2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
var _this2 = this;
var levels;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
if (this.isUcf) {
levels = ['error', 'warn', 'info', 'debug']; // ucf 环境初始化
usdk.logger.createLogger('user');
levels[usdk.logger.getLogLevel()] && (this.level = levels[usdk.logger.getLogLevel()]);
}
// 定义埋点方法 debug, info, warn, error
this.levels.forEach(function (level, index) {
var logMethod = console[level];
Object.assign(_this2, _defineProperty({}, level, function () {
var _this3 = this;
var currentLevelIndex = this.levels.findIndex(function (item) {
return item === _this3.level;
});
if (currentLevelIndex > index) {
return;
}
for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
content[_key] = arguments[_key];
}
if (this.isUcf) {
// ucf 处理逻辑 usdk logDebug logError logInfo logWarn
var keysUcf = {
debug: 'logDebug',
info: 'logInfo',
warn: 'logWarn',
error: 'logError'
};
// 处理日志埋点参数转为字符串，格式化
var contentStr = this.handleContent(content, level);
usdk.logger[keysUcf[level]]('user', contentStr, dateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss.S'));
return;
}
// 如果设置 console 的方法
var userAgent = window.navigator.userAgent.toLowerCase();
var isIE = userAgent.match(/msie/) != null || userAgent.match(/trident/) != null;
if (!isIE && this.enableConsole) {
logMethod.apply(this, this._handleContent(level, content));
}
// 如果开启日志存储并且支持 indexDB 并且在当前实例的日志级别记录范围
if (this.enableLogIndexDB && this._indexdb) {
// 处理日志埋点参数转为字符串，格式化
var _contentStr = this.handleContent(content, level);
this.track(_contentStr);
}
}));
});
// 如果关闭日志采集或者在客户端下不走下边操作表逻辑
if (!(!this._indexdb || this.isUcf)) {
_context.next = 4;
break;
}
return _context.abrupt("return");
case 4:
_context.prev = 4;
// 连接数据库,需要新建表时在更新数据库
this.deleteIDBDatabasePromise = this.deleteIndexdbStore();
_context.t0 = this.deleteIDBDatabasePromise;
if (!_context.t0) {
_context.next = 10;
break;
}
_context.next = 10;
return this.deleteIDBDatabasePromise;
case 10:
this.createDatabaseTablePromise = this.createDatabaseTable('HUI-ET-BASE-INFO');
_context.t1 = this.createDatabaseTablePromise;
if (!_context.t1) {
_context.next = 15;
break;
}
_context.next = 15;
return this.createDatabaseTablePromise;
case 15:
_context.next = 20;
break;
case 17:
_context.prev = 17;
_context.t2 = _context["catch"](4);
huiLogger.debug('@hsui/tracker 初始化失败', _context.t2);
case 20:
case "end":
return _context.stop();
}
}, _callee, this, [[4, 17]]);
}));
function _init() {
return _init2.apply(this, arguments);
}
return _init;
}() // 修改日志采集类配置项, 因为操作表架构是在初始化时执行，此时修改配置也不会再次更新表结构，所以不能在这里配置 maxSheetCount、expiredDays
}, {
key: "setConfig",
value: function () {
var _setConfig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
var _this4 = this;
var data,
configKeys,
dataKeys,
_args2 = arguments;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
data = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {};
configKeys = ['maxSheetItemCount', 'enableConsole', 'enableLogIndexDB'];
dataKeys = Object.keys(data);
dataKeys.map(function (key) {
configKeys.includes(key) && (_this4[key] = data[key]);
});
case 4:
case "end":
return _context2.stop();
}
}, _callee2);
}));
function setConfig() {
return _setConfig.apply(this, arguments);
}
return setConfig;
}() // 新建表
}, {
key: "createDatabaseTable",
value: function createDatabaseTable(sheetname) {
var _this5 = this;
return new Promise( /*#__PURE__*/function () {
var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(resolve, reject) {
var version, openIDBDatabase;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
_context3.prev = 0;
_context3.t0 = _this5.deleteIDBDatabasePromise;
if (!_context3.t0) {
_context3.next = 5;
break;
}
_context3.next = 5;
return _this5.deleteIDBDatabasePromise;
case 5:
_context3.next = 7;
return _this5.getDatabaseVersion();
case 7:
_context3.t1 = _context3.sent;
version = _context3.t1 + 1;
// 更新数据库
openIDBDatabase = _this5._indexdb.open('HuiTracker', version); // 如果指定的版本号，大于数据库的实际版本号，就会发生数据库升级事件 upgradeneeded
openIDBDatabase.onupgradeneeded = function (event) {
huiLogger.debug('更新 indexdb 数据库');
var IDBDatabase = event.target.result;
// 判断表是否存在
if (!IDBDatabase.objectStoreNames.contains(sheetname)) {
var IDBObjectStore = IDBDatabase.createObjectStore(sheetname, {
keyPath: 'id'
});
// 创建表之后创建索引，索引必须先创建再使用
IDBObjectStore.createIndex(sheetname, 'timestamp', {
unique: false
});
}
};
openIDBDatabase.onsuccess = function (event) {
var IDBDatabase = event.target.result;
IDBDatabase.close();
huiLogger.debug('打开 indexdb 数据库成功');
resolve(true);
};
openIDBDatabase.onerror = function (error) {
huiLogger.debug('打开 indexdb 数据库时出错', error);
_this5.sheetname = '';
reject(false);
};
_context3.next = 19;
break;
case 15:
_context3.prev = 15;
_context3.t2 = _context3["catch"](0);
huiLogger.debug('新建 indexdb 表时出错');
reject(false);
case 19:
case "end":
return _context3.stop();
}
}, _callee3, null, [[0, 15]]);
}));
return function (_x, _x2) {
return _ref.apply(this, arguments);
};
}());
}
// userId 在外框登录后存在一个基础信息表， 每次去表里取值
}, {
key: "track",
value: function () {
var _track = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
var _this6 = this;
var content,
userInfo,
openIDBDatabase,
_args6 = arguments;
return _regeneratorRuntime().wrap(function _callee6$(_context6) {
while (1) switch (_context6.prev = _context6.next) {
case 0:
content = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : '';
_context6.prev = 1;
_context6.t0 = this.deleteIDBDatabasePromise;
if (!_context6.t0) {
_context6.next = 6;
break;
}
_context6.next = 6;
return this.deleteIDBDatabasePromise;
case 6:
_context6.t1 = this.createDatabaseTablePromise;
if (!_context6.t1) {
_context6.next = 10;
break;
}
_context6.next = 10;
return this.createDatabaseTablePromise;
case 10:
_context6.t2 = this.getItemByIdPromise;
if (!_context6.t2) {
_context6.next = 14;
break;
}
_context6.next = 14;
return this.getItemByIdPromise;
case 14:
// 获取用户信息表里用户数据
this.getItemByIdPromise = this.getItemById('HUI-ET-BASE-INFO', 'userinfo');
_context6.t3 = this.getItemByIdPromise;
if (!_context6.t3) {
_context6.next = 20;
break;
}
_context6.next = 19;
return this.getItemByIdPromise;
case 19:
_context6.t3 = _context6.sent;
case 20:
userInfo = _context6.t3;
this.userId = userInfo && userInfo.userId ? userInfo.userId : '';
openIDBDatabase = this._indexdb.open('HuiTracker');
openIDBDatabase.onsuccess = /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(event) {
var IDBDatabase, sheetStoreNames, currentSheetname, nowSheetname, indexdbsheet, indexdbsheetCount;
return _regeneratorRuntime().wrap(function _callee5$(_context5) {
while (1) switch (_context5.prev = _context5.next) {
case 0:
huiLogger.debug('打开 indexdb 数据库成功');
IDBDatabase = event.target.result; // 如果没有设置 this.sheetname 判断 DBDatabase.objectStoreNames 是否含有当天表，如果没有创建当天 1 表，如果有找当天序号最大子表设置为 this.sheetname，
// 如果设置了 this.sheetname 按照 this.sheetname 创建新表
sheetStoreNames = filterLogTable(_toConsumableArray(IDBDatabase.objectStoreNames));
sheetStoreNames.forEach(function (item) {
var splitSheetName = item.split('-'),
todayDate = dateFormat(new Date(), 'yyyyMMdd');
// 如果存在当天的表，获取当天最新的表名存入 currentSheetname
if (splitSheetName[2] === todayDate) {
if (!currentSheetname || currentSheetname && parseInt(item.split('-')[3]) > parseInt(currentSheetname.split('-')[3])) {
currentSheetname = item;
}
}
});
// 如果 currentSheetname 没有值说明不存在当天的表，需要新建当天表,如果有设为 sheetname
if (!currentSheetname) {
_context5.next = 12;
break;
}
// 如果有当天表直接连表操作数据
// 判断当前表是否超过 50000 条，超出了需要新建当天子表，然后再次走 track 逻辑
nowSheetname = _this6.sheetname = currentSheetname; // 请求表
indexdbsheet = IDBDatabase.transaction([_this6.sheetname], 'readwrite').objectStore(_this6.sheetname); // 获取当前表存储条数
indexdbsheetCount = indexdbsheet.count();
indexdbsheetCount.onsuccess = /*#__PURE__*/function () {
var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(event) {
var indexdbsheetRequest;
return _regeneratorRuntime().wrap(function _callee4$(_context4) {
while (1) switch (_context4.prev = _context4.next) {
case 0:
if (!(event.target.result < _this6.maxSheetItemCount)) {
_context4.next = 7;
break;
}
// 添加数据
indexdbsheetRequest = indexdbsheet.add({
id: uuid(),
// 需要传递设置的主 key ：id
content: content,
timestamp: new Date().getTime(),
userId: _this6.userId ? _this6.userId : ''
});
indexdbsheetRequest.onsuccess = function (event) {
huiLogger.debug('indexdb 插入数据成功');
// // 处理结束需要关闭数据库链接，否则后续操作会不正常执行
IDBDatabase.close();
};
indexdbsheetRequest.onerror = function (error) {
huiLogger.debug('indexdb 插入数据时出错', error);
IDBDatabase.close();
};
_this6.sheetname = '';
_context4.next = 24;
break;
case 7:
// 新建表这里用 nowSheetname 保留埋点时的 this.sheetname, 否则多个埋点同时触发该条件时子表名序号不是连贯的
_this6.sheetname = "HUI-ET-".concat(dateFormat(new Date(), 'yyyyMMdd')) + '-' + (parseInt(nowSheetname.split('-')[3]) + 1);
// 调用新建表方法，在新建表之后再次调用 track
_context4.prev = 8;
IDBDatabase.close();
// 如果当前有创建表的操作，等创建好之后在执行以下逻辑
_context4.t0 = _this6.createDatabaseTablePromise;
if (!_context4.t0) {
_context4.next = 14;
break;
}
_context4.next = 14;
return _this6.createDatabaseTablePromise;
case 14:
_this6.createDatabaseTablePromise = _this6.createDatabaseTable(_this6.sheetname);
_context4.next = 17;
return _this6.createDatabaseTablePromise;
case 17:
_this6.track(content);
_context4.next = 24;
break;
case 20:
_context4.prev = 20;
_context4.t1 = _context4["catch"](8);
huiLogger.debug('新建 indexdb 表报错');
IDBDatabase.close();
case 24:
case "end":
return _context4.stop();
}
}, _callee4, null, [[8, 20]]);
}));
return function (_x4) {
return _ref3.apply(this, arguments);
};
}();
indexdbsheetCount.onerror = function (error) {
huiLogger.debug('indexdb 获取表存储数量时出错', error);
_this6.sheetname = '';
IDBDatabase.close();
};
_context5.next = 28;
break;
case 12:
IDBDatabase.close();
// 如果没有当天表需要新建当天表，然后再次走 track 逻辑
_this6.sheetname = "HUI-ET-".concat(dateFormat(new Date(), 'yyyyMMdd'), "-1");
// 调用新建表方法，在新建表之后再次调用 track
_context5.prev = 14;
_context5.t0 = _this6.createDatabaseTablePromise;
if (!_context5.t0) {
_context5.next = 19;
break;
}
_context5.next = 19;
return _this6.createDatabaseTablePromise;
case 19:
_this6.createDatabaseTablePromise = _this6.createDatabaseTable(_this6.sheetname);
_context5.next = 22;
return _this6.createDatabaseTablePromise;
case 22:
_this6.track(content);
_context5.next = 28;
break;
case 25:
_context5.prev = 25;
_context5.t1 = _context5["catch"](14);
huiLogger.debug('新建 indexdb 表报错');
case 28:
case "end":
return _context5.stop();
}
}, _callee5, null, [[14, 25]]);
}));
return function (_x3) {
return _ref2.apply(this, arguments);
};
}();
openIDBDatabase.onerror = function (error) {
huiLogger.debug('打开 indexdb 数据库时出错', error);
_this6.sheetname = null;
};
_context6.next = 32;
break;
case 27:
_context6.prev = 27;
_context6.t4 = _context6["catch"](1);
huiLogger.debug('indexdb 埋点时出错，日志未记录', _context6.t4);
this.sheetname = null;
return _context6.abrupt("return");
case 32:
case "end":
return _context6.stop();
}
}, _callee6, this, [[1, 27]]);
}));
function track() {
return _track.apply(this, arguments);
}
return track;
}() // 格式化日志内容
}, {
key: "handleContent",
value: function handleContent() {
var content = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'info';
var logTime = dateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss.S');
var logLevel = level.toUpperCase();
// content 参数数组拼接为字符串
var contentStr = content.reduce(function (total, value) {
try {
// 处理函数类型
if (Object.prototype.toString.call(value) === '[object Function]') {
return "".concat(total, " ").concat(value.toString());
}
// 处理对象、数组
if (Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]') {
return "".concat(total, " ").concat(JSON.stringify(value));
}
return "".concat(total, " ").concat(value);
} catch (err) {
return total;
}
}, '');
// ucf 客户端下不加密
if (this.isUcf) {
return contentStr;
} else {
return this.encryption ? sm4.encrypt("[".concat(logTime, "] [").concat(logLevel, "]").concat(contentStr), KEY) : "[".concat(logTime, "] [").concat(logLevel, "]").concat(contentStr);
}
}
// 打开数据库读取数据
}, {
key: "openDatabase",
value: function openDatabase(_ref4) {
var onsuccess = _ref4.onsuccess,
onerror = _ref4.onerror;
var openIDBDatabase = this._indexdb.open('HuiTracker');
openIDBDatabase.onsuccess = onsuccess;
openIDBDatabase.onerror = onerror;
}
// 获取本地日志
}, {
key: "getLocalLogs",
value: function getLocalLogs(startTime, endTime, userId) {
var _this7 = this;
return new Promise( /*#__PURE__*/function () {
var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(resolve, reject) {
var validLogs, getTablePromiseList, keyRangeValue;
return _regeneratorRuntime().wrap(function _callee8$(_context8) {
while (1) switch (_context8.prev = _context8.next) {
case 0:
_context8.prev = 0;
_context8.t0 = _this7.deleteIDBDatabasePromise;
if (!_context8.t0) {
_context8.next = 5;
break;
}
_context8.next = 5;
return _this7.deleteIDBDatabasePromise;
case 5:
validLogs = [], getTablePromiseList = [];
keyRangeValue = IDBKeyRange.bound(startTime, endTime);
_this7.openDatabase({
onsuccess: function onsuccess(event) {
var IDBDatabase = event.target.result;
getTablePromiseList = filterLogTable(_toConsumableArray(IDBDatabase.objectStoreNames)).map( /*#__PURE__*/function () {
var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(item) {
return _regeneratorRuntime().wrap(function _callee7$(_context7) {
while (1) switch (_context7.prev = _context7.next) {
case 0:
return _context7.abrupt("return", _this7.getTableBydatetime(item, keyRangeValue, IDBDatabase));
case 1:
case "end":
return _context7.stop();
}
}, _callee7);
}));
return function (_x7) {
return _ref6.apply(this, arguments);
};
}());
Promise.all(getTablePromiseList).then(function (values) {
validLogs = values.reduce(function (target, item) {
return item ? target.concat(item) : target;
}, []);
validLogs.forEach(function (item) {
item.content = _this7.encryption ? sm4.decrypt(item.content, KEY) : item.content;
});
var filterLogsStr = _this7.filterLogs(validLogs, userId);
IDBDatabase.close();
resolve(filterLogsStr);
}).catch(function (err) {
huiLogger.error(err);
IDBDatabase.close();
reject(false);
});
},
onerror: function onerror(error) {
huiLogger.error('打开 indexdb 数据库时出错', error);
reject(false);
}
});
_context8.next = 14;
break;
case 10:
_context8.prev = 10;
_context8.t1 = _context8["catch"](0);
huiLogger.error('获取本地 indexdb 日志失败');
reject(false);
case 14:
case "end":
return _context8.stop();
}
}, _callee8, null, [[0, 10]]);
}));
return function (_x5, _x6) {
return _ref5.apply(this, arguments);
};
}());
}
// 处理收集的日志，过滤用户，拼接成字符串
}, {
key: "filterLogs",
value: function filterLogs(logs, userId) {
return logs.reduce(function (total, current) {
if (current.userId === userId) {
return total.concat(current.content, '\n');
}
return total;
}, []);
}
// 插入单条记录 存储用户信息使用
}, {
key: "putItemById",
value: function putItemById(sheetname, data) {
var _this8 = this;
return new Promise( /*#__PURE__*/function () {
var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(resolve, reject) {
return _regeneratorRuntime().wrap(function _callee9$(_context9) {
while (1) switch (_context9.prev = _context9.next) {
case 0:
_context9.prev = 0;
_context9.t0 = _this8.deleteIDBDatabasePromise;
if (!_context9.t0) {
_context9.next = 5;
break;
}
_context9.next = 5;
return _this8.deleteIDBDatabasePromise;
case 5:
_context9.t1 = _this8.createDatabaseTablePromise;
if (!_context9.t1) {
_context9.next = 9;
break;
}
_context9.next = 9;
return _this8.createDatabaseTablePromise;
case 9:
_this8.openDatabase({
onsuccess: function onsuccess(event) {
var IDBDatabase = event.target.result;
if (IDBDatabase.objectStoreNames.contains(sheetname)) {
var indexdbsheet = IDBDatabase.transaction([sheetname], 'readwrite').objectStore(sheetname);
var indexdbsheetRequest = indexdbsheet.put(data);
indexdbsheetRequest.onsuccess = function (event) {
// // 处理结束需要关闭数据库链接，否则后续操作会不正常执行
IDBDatabase.close();
resolve(true);
};
indexdbsheetRequest.onerror = function (error) {
IDBDatabase.close();
huiLogger.error('indexdb 插入单条记录时出错', error);
reject(false);
};
} else {
IDBDatabase.close();
reject(false);
}
},
onerror: function onerror(error) {
huiLogger.error('打开 indexdb 数据库时出错', error);
reject(false);
}
});
_context9.next = 15;
break;
case 12:
_context9.prev = 12;
_context9.t2 = _context9["catch"](0);
reject(false);
case 15:
case "end":
return _context9.stop();
}
}, _callee9, null, [[0, 12]]);
}));
return function (_x8, _x9) {
return _ref7.apply(this, arguments);
};
}());
}
// 根据 id 获取单条数据
}, {
key: "getItemById",
value: function getItemById(sheetname, id) {
var _this9 = this;
return new Promise( /*#__PURE__*/function () {
var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(resolve, reject) {
return _regeneratorRuntime().wrap(function _callee10$(_context10) {
while (1) switch (_context10.prev = _context10.next) {
case 0:
_context10.prev = 0;
_context10.t0 = _this9.deleteIDBDatabasePromise;
if (!_context10.t0) {
_context10.next = 5;
break;
}
_context10.next = 5;
return _this9.deleteIDBDatabasePromise;
case 5:
_this9.openDatabase({
onsuccess: function onsuccess(event) {
huiLogger.debug('打开 indexdb 数据库成功');
var IDBDatabase = event.target.result;
if (IDBDatabase.objectStoreNames.contains(sheetname)) {
var indexdbsheet = IDBDatabase.transaction(sheetname, 'readwrite').objectStore(sheetname);
var request = indexdbsheet.get(id);
request.onsuccess = function (event) {
huiLogger.debug(event.target.result);
IDBDatabase.close();
resolve(event.target.result);
};
request.onerror = function (error) {
huiLogger.error(error);
IDBDatabase.close();
reject(false);
};
} else {
IDBDatabase.close();
resolve(false);
}
},
onerror: function onerror(error) {
huiLogger.error('打开 indexdb 数据库时出错', error);
reject(false);
}
});
_context10.next = 11;
break;
case 8:
_context10.prev = 8;
_context10.t1 = _context10["catch"](0);
reject(false);
case 11:
case "end":
return _context10.stop();
}
}, _callee10, null, [[0, 8]]);
}));
return function (_x10, _x11) {
return _ref8.apply(this, arguments);
};
}());
}
// 根据时间周期获取单个表里复核范围的日志 游标
}, {
key: "getTableBydatetime",
value: function getTableBydatetime(tableName, keyRangeValue, IDBDatabase) {
return new Promise(function (resolve, reject) {
try {
var sheetQueryList = [];
var indexdbsheet = IDBDatabase.transaction([tableName], 'readwrite').objectStore(tableName);
var indexdbIndex = indexdbsheet.index(tableName);
var indexdbCursor = indexdbIndex.openCursor(keyRangeValue);
indexdbCursor.onsuccess = function (event) {
var cursor = event.target.result;
if (cursor) {
sheetQueryList.push(cursor.value);
cursor.continue();
} else {
resolve(sheetQueryList);
}
};
indexdbCursor.onerror = function (error) {
huiLogger.error(error);
reject(false);
};
} catch (error) {
huiLogger.error('获取本地日志时报错');
reject(false);
}
});
}
// 删除过期时间的表
}, {
key: "deleteIndexdbStore",
value: function deleteIndexdbStore() {
var _this10 = this;
return new Promise( /*#__PURE__*/function () {
var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(resolve, reject) {
var version, openIDBDatabase;
return _regeneratorRuntime().wrap(function _callee11$(_context11) {
while (1) switch (_context11.prev = _context11.next) {
case 0:
_context11.next = 2;
return _this10.getDatabaseVersion();
case 2:
_context11.t0 = _context11.sent;
version = _context11.t0 + 1;
openIDBDatabase = _this10._indexdb.open('HuiTracker', version);
openIDBDatabase.onupgradeneeded = function (event) {
var IDBDatabase = event.target.result;
var currentSheetNames = filterLogTable(_toConsumableArray(IDBDatabase.objectStoreNames));
var expiredDate = dateFormat(new Date(new Date().getTime() - _this10.expiredDays * 1000 * 60 * 60 * 24), 'yyyyMMdd');
// 筛选出过期的表和在有效期内的表
var classifySheetNames = currentSheetNames.reduce(function (target, item) {
if (parseInt(item.split('-')[2]) <= parseInt(expiredDate)) {
// 筛选超出过期时间的表
target.expiredSheetNames.push(item);
} else {
// 筛选超出有效期时间的表
target.validSheetNames.push(item);
}
return target;
}, {
expiredSheetNames: [],
validSheetNames: []
});
// 如果有效日期的表超出设置的最大表数量，筛选出有效表内最早的表
var validCountDifferent = classifySheetNames.validSheetNames.length - _this10.maxSheetCount,
deleteSheetNames = [];
if (validCountDifferent > 0) {
// 对有效日期内的表进行排序，筛选出超出最大表数量的表
classifySheetNames.validSheetNames = sortSheetName(classifySheetNames.validSheetNames);
deleteSheetNames = classifySheetNames.validSheetNames.splice(0, validCountDifferent);
}
classifySheetNames.expiredSheetNames = classifySheetNames.expiredSheetNames.concat(deleteSheetNames);
// 判断当前数据库是否有该表名有才做删除逻辑
classifySheetNames.expiredSheetNames.forEach(function (item) {
IDBDatabase.objectStoreNames.contains(item) && IDBDatabase.deleteObjectStore(item);
});
};
openIDBDatabase.onsuccess = function (event) {
var IDBDatabase = event.target.result;
IDBDatabase.close();
resolve(true);
};
openIDBDatabase.onerror = function (error) {
huiLogger.error('打开 indexdb 数据库 HuiTracker 时出错', error);
reject(false);
};
case 8:
case "end":
return _context11.stop();
}
}, _callee11);
}));
return function (_x12, _x13) {
return _ref9.apply(this, arguments);
};
}());
}
// 获取数据库版本号
}, {
key: "getDatabaseVersion",
value: function getDatabaseVersion() {
var _this11 = this;
return new Promise(function (resolve, reject) {
var openIDBDatabase = _this11._indexdb.open('HuiTracker');
openIDBDatabase.onsuccess = function (event) {
var IDBDatabase = event.target.result;
var version = IDBDatabase.version;
IDBDatabase.close();
resolve(version);
};
openIDBDatabase.onerror = function (error) {
huiLogger.error('打开 indexdb 数据库 HuiTracker 时出错', error);
reject(error);
};
});
}
}]);
return LogLevel;
}(SuperClassLogLevel);
/**
* 日期格式化
* date: 日期对象
* format：时间格式
* 引用 dateFormat(new Date("2016-05-05 12:23:26"),"yyyy-MM-dd HH:mm:ss")
*/
function dateFormat(date, format) {
var o = {
'M+': date.getMonth() + 1,
//月份
'd+': date.getDate(),
//日
'H+': date.getHours(),
//小时
'm+': date.getMinutes(),
//分
's+': date.getSeconds(),
//秒
'q+': Math.floor((date.getMonth() + 3) / 3),
//季度
S: date.getMilliseconds() //毫秒
};
if (/(y+)/.test(format)) {
format = format.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
}
for (var k in o) if (new RegExp('(' + k + ')').test(format)) format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length));
return format;
}
/**
* 表名排序
* 表名集合
*/
function sortSheetName(arr) {
// 创建一个数组对象，列出每天对应的表集合
var dateArrayObj = arr.reduce(function (tar, item) {
var key = parseInt(item.split('-')[2]);
if (tar[key]) {
tar[key].push(item);
return tar;
} else {
tar[key] = [item];
return tar;
}
}, {});
// 获取对象数组的 key 集合，并根据大小排序
var keysArr = Object.keys(dateArrayObj).sort(function (objA, objB) {
if (objA < objB) {
return -1;
} else if (objA > objB) {
return 1;
}
});
// 针对每天的表进行排序，在按照日期前后拼接在一起
var finallySheetNames = keysArr.reduce(function (tar, item) {
dateArrayObj[item].sort(function (objA, objB) {
if (parseInt(objA.split('-')[3]) < parseInt(objB.split('-')[3])) {
return -1;
} else if (parseInt(objA.split('-')[3]) > parseInt(objB.split('-')[3])) {
return 1;
}
});
return tar.concat(dateArrayObj[item]);
}, []);
return finallySheetNames;
}
// 过滤出存储日志埋点的表
function filterLogTable(names) {
// 匹配以 HUI-ET- 开头接八位数字接任意字符的字符串
var reg = /^HUI-ET-\d{8}.*/;
return names.filter(function (item) {
return reg.test(item);
});
}
/**
* simple generate uuid
* 支持 ie10 及以上
* 基于 uuid v4 添加 performance.now 避免重复
*/
function uuid() {
var d = Date.now();
if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
d += performance.now(); //use high-precision timer if available
}
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
});
}
export function createLogger() {
var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return new LogLevel(data);
}