@aochuang/client-sdk 1.0.367 → 1.0.369

package/utils/log.js

@@ -1,243 +1,602 @@
-import { unique } from './string'
-import { parse } from './json'
 import { formatDate } from './date'
 
-function requestAnimationFrame (callback) {
-	if (typeof uni === 'object') {
-		return setTimeout(() => {
-			callback && callback()
-		}, 10)
-	} else {
-		return window.requestAnimationFrame(() => {
-			callback && callback()
-		})
+let uniqueId = Date.now()
+
+function unique () {
+	uniqueId++
+	return uniqueId
+}
+
+function parse (value) {
+	try {
+		return typeof value === 'string' ? JSON.parse(value) : value
+	} catch (e) {
+		return value
+	}
+}
+
+const INDEXED_DB_VERSION = 2
+const INDEXED_DB_STORE_NAME = 'logs'
+const INDEXED_DB_META_STORE_NAME = 'meta'
+const INDEXED_DB_ORDER_INDEX_NAME = 'order'
+const INDEXED_DB_MAX_SIZE = 50 * 1024 * 1024
+const INDEXED_DB_STATS_KEY = 'stats'
+
+function isUniRuntime () {
+	try {
+		return !!uni
+	} catch (e) {
+		return false
+	}
+}
+
+function isIndexedDbSupported () {
+	return typeof window !== 'undefined' && !isUniRuntime() && !!window.indexedDB
+}
+
+function getLogSize (item) {
+	return item && item.size ? item.size : JSON.stringify(item || {}).length
+}
+
+function getLogByteSize (item) {
+	const value = JSON.stringify(item || {})
+	if (typeof Blob !== 'undefined') {
+		return new Blob([value]).size
+	}
+	return unescape(encodeURIComponent(value)).length
+}
+
+function normalizeLogStore (store) {
+	let nextStore = store
+	if (!nextStore) {
+		nextStore = {
+			size: 0,
+			data: []
+		}
+	}
+	if (Array.isArray(nextStore)) {
+		let totalSize = 0
+		nextStore = {
+			data: nextStore.map(item => {
+				if (item && !item.size) {
+					item.size = JSON.stringify(item).length
+				}
+				totalSize += getLogSize(item)
+				return item
+			})
+		}
+		nextStore.size = totalSize
+	}
+	if (!Array.isArray(nextStore.data)) {
+		nextStore.data = []
+	}
+	if (!nextStore.size) {
+		nextStore.size = nextStore.data.reduce((totalSize, item) => {
+			return totalSize + getLogSize(item)
+		}, 0)
+	}
+	return nextStore
+}
+
+function parseLogStoreValue (value) {
+	if (!value) {
+		return null
+	}
+	if (typeof value === 'string') {
+		value = parse(value)
+	}
+	return normalizeLogStore(value)
+}
+
+function readLegacyStorage (storageKey) {
+	if (isUniRuntime()) {
+		return uni.getStorageSync(storageKey)
+	}
+	if (typeof window !== 'undefined' && window.localStorage) {
+		return window.localStorage.getItem(storageKey)
+	}
+	return null
+}
+
+function writeLegacyStorage (storageKey, value) {
+	if (isUniRuntime()) {
+		uni.setStorageSync(storageKey, value)
+		return
+	}
+	if (typeof window !== 'undefined' && window.localStorage) {
+		window.localStorage.setItem(storageKey, typeof value === 'string' ? value : JSON.stringify(value))
+	}
+}
+
+function removeLegacyStorage (storageKey) {
+	if (isUniRuntime()) {
+		uni.removeStorageSync(storageKey)
+		return
+	}
+	if (typeof window !== 'undefined' && window.localStorage) {
+		window.localStorage.removeItem(storageKey)
+	}
+}
+
+function hashString (value) {
+	let hash = 2166136261
+	for (let index = 0; index < value.length; index++) {
+		hash ^= value.charCodeAt(index)
+		hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24)
+	}
+	return (hash >>> 0).toString(16)
+}
+
+function getLogRecordId (log) {
+	if (log && log.id !== undefined && log.id !== null) {
+		return `id:${log.id}`
+	}
+	const value = JSON.stringify(log || {})
+	return `legacy:${hashString(value)}:${value.length}`
+}
+
+function createIndexedDbStores (db) {
+	const logStore = db.createObjectStore(INDEXED_DB_STORE_NAME, { keyPath: 'recordId' })
+	logStore.createIndex(INDEXED_DB_ORDER_INDEX_NAME, 'order', { unique: false })
+	if (!db.objectStoreNames.contains(INDEXED_DB_META_STORE_NAME)) {
+		db.createObjectStore(INDEXED_DB_META_STORE_NAME, { keyPath: 'key' })
 	}
+	return logStore
+}
+
+function createIndexedDbRecord (log, order) {
+	return {
+		recordId: getLogRecordId(log),
+		order,
+		byteSize: getLogByteSize(log),
+		log
+	}
+}
+
+function uniqueLogs (logs) {
+	const recordIds = Object.create(null)
+	return logs.filter(log => {
+		const recordId = getLogRecordId(log)
+		if (recordIds[recordId]) {
+			return false
+		}
+		recordIds[recordId] = true
+		return true
+	})
 }
 
-function cancelAnimationFrame (rafId) {
-	if (typeof uni === 'object') {
-		clearTimeout(rafId)
-	} else {
-		window.cancelAnimationFrame(rafId)
-	}
-}
-
-const LogManage = {
-    list: [],
-    add: (logInstance) => {
-        if (!(logInstance instanceof Log)) {
-            throw new Error('不是有效日志实例')
-        }
-        if (!this.list.some(v => v === logInstance)) {
-            throw new Error('日志实例已存在')
-        }
-        this.list.push(logInstance)
-    },
-    remove: (logInstance) => {
-        let index = -1
-        this.list.some((v, i) => {
-            if (v === logInstance) {
-                index = i
-                return true
-            }
-        })
-        if (index < 0) {
-            return
-        }
-        this.list.splice(index, 1)
-    }
+function trimRecordsToIndexedDbLimit (records) {
+	let totalBytes = 0
+	const retainedRecords = []
+	records.some(record => {
+		if (record.byteSize + totalBytes > INDEXED_DB_MAX_SIZE) {
+			return true
+		}
+		retainedRecords.push(record)
+		totalBytes += record.byteSize
+		return false
+	})
+	return {
+		records: retainedRecords,
+		totalBytes,
+		removedCount: records.length - retainedRecords.length
+	}
 }
 
 export default class Log {
 
-    prefix = 'log'
-    
-    name = null
-
-    tempStore = []
-
-    beforeAddCallback = null
-
-    constructor (options) {
-        options = Object.assign({
-            name: null,
-						console: false, // 是否控制台打印
-            maxSize: 1024 * 1024 * 3 // 最多存3M的日志数据
-        }, options)
-        if (!options.name) {
-            throw new Error('必须指定日志的name名称')
-        }
-        if (LogManage.list.some(v => v.name === options.name)) {
-            throw new Error('已存在同名的日志实例')
-        }
-				this.options = options
-        this.maxSize = options.maxSize
-        this.name = options.name
-        this.validTime = options.validTime
-    }
-
-    get storageKey () {
-        return this.prefix + '_' + this.name 
-    }
-
-    onBeforeAdd (callback) {
-        this.beforeAddCallback = callback
-    }
-
-    /**   
-     * 新增日志到内存
-    */
-    addLog (data) {
-        data = Object.assign({
-            group: this.defautGroup,
-            refererId: undefined, // 可以关联一个日志
-            content: null
-        }, data, { 
-            createTime: formatDate(new Date())
-        })
-        data.id = unique(data.group)
-        if (this.beforeAddCallback && this.beforeAddCallback({
-            data
-        }) === false) {
-            return
-        }
-		const size = JSON.stringify(data).length
-		data.size = size
-        this.tempStore.push(data)
-        if (this.tempStore.length > 5) {
-            this.publishLogData().then(null, err => {
-				console.log(err)
+	static checkAndSync (storageKeys) {
+		const keys = [].concat(storageKeys || []).filter((storageKey, index, list) => {
+			return typeof storageKey === 'string' && storageKey && list.indexOf(storageKey) === index
+		})
+		return Promise.all(keys.map(storageKey => {
+			const log = new Log({ name: storageKey })
+			log._customStorageKey = storageKey
+			return log.checkAndSync().then(result => {
+				return log._closeIndexedDb().then(() => {
+					return Object.assign({ storageKey }, result)
+				})
 			})
-        }
-		if (this.options.console) {
-			console.log(`【${this.name || 'operateLog'}】${JSON.stringify(data) || '--'}`)
+		}))
+	}
+
+	constructor (options) {
+		this.prefix = 'log'
+		this.name = null
+		this.tempStore = []
+		this.beforeAddCallback = null
+		this._writePromise = Promise.resolve()
+		this._indexedDbPromise = null
+		this._syncPromise = null
+		this._customStorageKey = null
+		options = Object.assign({
+			name: null,
+			console: false, // 是否控制台打印
+			maxSize: 1024 * 1024 * 3 // 非网页版本默认最多存3M日志数据
+		}, options)
+		if (!options.name) {
+			throw new Error('必须指定日志的name名称')
 		}
-        return data
-    }
-
-    /**
-     * 清空本地日志
-    */
-    clearLogData () {
-        return new Promise((resolve) => {
-            this.tempStore = []
-						if (typeof uni !== 'undefined') {
-							uni.removeStorageSync(this.storageKey)
-						} else {
-							window.localStorage.removeItem(this.storageKey)
-						}
-            resolve()
-        })
-    }
+		this.options = options
+		this.maxSize = options.maxSize
+		this.name = options.name
+		this.validTime = options.validTime
+	}
+
+	get storageKey () {
+		return this._customStorageKey || this.prefix + '_' + this.name
+	}
+
+	get useIndexedDb () {
+		return isIndexedDbSupported()
+	}
+
+	get indexedDbName () {
+		return this.storageKey
+	}
+
+	onBeforeAdd (callback) {
+		this.beforeAddCallback = callback
+	}
+
+	_enqueueWrite (callback) {
+		const task = this._writePromise.then(callback, callback)
+		this._writePromise = task.catch(() => {})
+		return task
+	}
+
+	_closeIndexedDb () {
+		const indexedDbPromise = this._indexedDbPromise
+		this._indexedDbPromise = null
+		if (!indexedDbPromise) {
+			return Promise.resolve()
+		}
+		return indexedDbPromise.then(db => {
+			db.close()
+		}, () => {})
+	}
+
+	_upgradeIndexedDb (request) {
+		const db = request.result
+		const transaction = request.transaction
+		if (!db.objectStoreNames.contains(INDEXED_DB_STORE_NAME)) {
+			createIndexedDbStores(db)
+			transaction.objectStore(INDEXED_DB_META_STORE_NAME).put({
+				key: INDEXED_DB_STATS_KEY,
+				totalBytes: 0,
+				nextOrder: 0
+			})
+			return
+		}
+
+		const legacyStore = transaction.objectStore(INDEXED_DB_STORE_NAME)
+		const legacyRequest = legacyStore.get(this.storageKey)
+		legacyRequest.onerror = () => {
+			transaction.abort()
+		}
+		legacyRequest.onsuccess = () => {
+			let legacyLogStore = null
+			try {
+				const result = legacyRequest.result
+				legacyLogStore = result && result.value ? parseLogStoreValue(result.value) : null
+			} catch (e) {
+				legacyLogStore = null
+			}
+			db.deleteObjectStore(INDEXED_DB_STORE_NAME)
+			if (db.objectStoreNames.contains(INDEXED_DB_META_STORE_NAME)) {
+				db.deleteObjectStore(INDEXED_DB_META_STORE_NAME)
+			}
+			const logStore = createIndexedDbStores(db)
+			const logs = uniqueLogs(legacyLogStore ? legacyLogStore.data : [])
+			const records = logs.map((log, index) => createIndexedDbRecord(log, logs.length - index))
+			const result = trimRecordsToIndexedDbLimit(records)
+			result.records.forEach(record => logStore.put(record))
+			transaction.objectStore(INDEXED_DB_META_STORE_NAME).put({
+				key: INDEXED_DB_STATS_KEY,
+				totalBytes: result.totalBytes,
+				nextOrder: logs.length
+			})
+		}
+	}
 
-    loadLogData () {
+	openIndexedDb () {
+		if (!this.useIndexedDb) {
+			return Promise.reject(new Error('indexedDB不可用'))
+		}
+		if (this._indexedDbPromise) {
+			return this._indexedDbPromise
+		}
+		this._indexedDbPromise = new Promise((resolve, reject) => {
+			const request = window.indexedDB.open(this.indexedDbName, INDEXED_DB_VERSION)
+			request.onerror = () => {
+				this._indexedDbPromise = null
+				reject(request.error || new Error('打开日志数据库失败'))
+			}
+			request.onupgradeneeded = () => {
+				this._upgradeIndexedDb(request)
+			}
+			request.onsuccess = () => {
+				const db = request.result
+				db.onversionchange = () => {
+					db.close()
+					this._indexedDbPromise = null
+				}
+				resolve(db)
+			}
+		})
+		return this._indexedDbPromise
+	}
+
+	_readIndexedDbLogData () {
+		return this.openIndexedDb().then(db => {
 			return new Promise((resolve, reject) => {
-				if (this._lastLoadLogDataRaf) {
-					this._lastLoadLogDataRaf.cancelFn()
+				const transaction = db.transaction([INDEXED_DB_STORE_NAME], 'readonly')
+				const store = transaction.objectStore(INDEXED_DB_STORE_NAME)
+				const request = store.index(INDEXED_DB_ORDER_INDEX_NAME).openCursor(null, 'prev')
+				const data = []
+				let size = 0
+				request.onerror = () => {
+					reject(request.error || new Error('读取日志失败'))
 				}
-				let rafId = null
-				this._lastLoadLogDataRaf = {
-					cancelFn: () => {
-						cancelAnimationFrame(rafId)
-						this._lastLoadLogDataRaf = null
-						reject('cancel')
-					},
-					execFn: () => {
-						rafId = requestAnimationFrame(() => {
-							let localTempStore
-							if (typeof uni !== 'undefined') {
-								localTempStore = uni.getStorageSync(this.storageKey)
-							} else {
-								localTempStore = window.localStorage.getItem(this.storageKey)
-							}
-							if (localTempStore) {
-								localTempStore = parse(localTempStore) 
-									if (Array.isArray(localTempStore)) {
-										let totalSize = 0
-										localTempStore = {
-											data: localTempStore.map(v => {
-												if (!v.size) {
-													v.size = JSON.stringify(v).length
-												}
-												totalSize += v.size
-												return v
-											})
-										}
-										localTempStore.size = totalSize
-									}
-							}
-							if (!localTempStore) {
-								localTempStore = {
-										size: 0,
-										data: []
-									}
-							}
-							// 自清理一下
-							if (this._lastLoadLogDataRaf) {
-								cancelAnimationFrame(this._lastLoadLogDataRaf)
-								this._lastLoadLogDataRaf = null
-							}
-							resolve(localTempStore)
-						})
+				request.onsuccess = event => {
+					const cursor = event.target.result
+					if (!cursor) {
+						resolve({ size, data })
+						return
 					}
+					data.push(cursor.value.log)
+					size += getLogSize(cursor.value.log)
+					cursor.continue()
 				}
-				this._lastLoadLogDataRaf.execFn()
 			})
-    }
+		})
+	}
 
-    publishLogData () {
-        return new Promise((resolve, reject) => {
-					if (this._lastPublishLogDataRaf) {
-						this._lastPublishLogDataRaf.cancelFn()
+	_writeIndexedDbLogs (logs) {
+		if (!logs.length) {
+			return Promise.resolve({ migratedCount: 0, duplicateCount: 0, removedCount: 0 })
+		}
+		const uniqueLogList = uniqueLogs(logs)
+		const repeatedInputCount = logs.length - uniqueLogList.length
+		return this.openIndexedDb().then(db => {
+			return new Promise((resolve, reject) => {
+				const transaction = db.transaction(
+					[INDEXED_DB_STORE_NAME, INDEXED_DB_META_STORE_NAME],
+					'readwrite'
+				)
+				const store = transaction.objectStore(INDEXED_DB_STORE_NAME)
+				const metaStore = transaction.objectStore(INDEXED_DB_META_STORE_NAME)
+				const metaRequest = metaStore.get(INDEXED_DB_STATS_KEY)
+				let result = null
+				transaction.oncomplete = () => {
+					resolve(result || { migratedCount: 0, duplicateCount: 0, removedCount: 0 })
+				}
+				transaction.onerror = () => {
+					reject(transaction.error || new Error('写入日志失败'))
+				}
+				transaction.onabort = () => {
+					reject(transaction.error || new Error('写入日志失败'))
+				}
+				metaRequest.onsuccess = () => {
+					const stats = metaRequest.result || {
+						key: INDEXED_DB_STATS_KEY,
+						totalBytes: 0,
+						nextOrder: 0
 					}
-					let rafId = null
-					this._lastPublishLogDataRaf = {
-						cancelFn: () => {
-							cancelAnimationFrame(rafId)
-							this._lastPublishLogDataRaf = null
-							reject('cancel')
-						},
-						execFn: () => {
-							if (!this.tempStore || !this.tempStore.length) {
-								return resolve()
+					const records = uniqueLogList.map((log, index) => {
+						return createIndexedDbRecord(log, stats.nextOrder + uniqueLogList.length - index)
+					})
+					let pendingCount = records.length
+					let duplicateCount = repeatedInputCount
+					records.forEach(record => {
+						const getRequest = store.get(record.recordId)
+						getRequest.onsuccess = () => {
+							if (getRequest.result) {
+								stats.totalBytes -= getRequest.result.byteSize || 0
+								duplicateCount++
+							}
+							stats.totalBytes += record.byteSize
+							store.put(record)
+							pendingCount--
+							if (!pendingCount) {
+								stats.nextOrder += uniqueLogList.length
+								trimOldestLogs(stats, duplicateCount)
 							}
-							rafId = requestAnimationFrame(() => {
-								this.loadLogData().then((localTempStore) => {
-									const allData = [].concat(this.tempStore, localTempStore.data)
-									const nextLocalStore = {
-										size: 0,
-										data: []
-									}
-									allData.some((item, index) => {
-										if (item.size + nextLocalStore.size >= this.maxSize) {
-											return true
-										}
-										nextLocalStore.data.push(item)
-										nextLocalStore.size = nextLocalStore.size + item.size
-									})
-									if (typeof uni !== 'undefined') {
-										uni.setStorageSync(this.storageKey, nextLocalStore)
-									} else {
-										window.localStorage.setItem(this.storageKey, JSON.stringify(nextLocalStore))
-									}
-									this.tempStore = []
-									// 自清理一下
-									if (this._lastPublishLogDataRaf) {
-										cancelAnimationFrame(this._lastPublishLogDataRaf)
-										this._lastPublishLogDataRaf = null
-									}
-									resolve()
-								}, reject)
-							})
+						}
+					})
+
+					function trimOldestLogs (nextStats, nextDuplicateCount) {
+						let removedCount = 0
+						const cursorRequest = store.index(INDEXED_DB_ORDER_INDEX_NAME).openCursor(null, 'next')
+						cursorRequest.onsuccess = event => {
+							const cursor = event.target.result
+							if (nextStats.totalBytes <= INDEXED_DB_MAX_SIZE || !cursor) {
+								metaStore.put(nextStats)
+								result = {
+									migratedCount: logs.length - nextDuplicateCount,
+									duplicateCount: nextDuplicateCount,
+									removedCount
+								}
+								return
+							}
+							nextStats.totalBytes -= cursor.value.byteSize || 0
+							cursor.delete()
+							removedCount++
+							cursor.continue()
 						}
 					}
-					this._lastPublishLogDataRaf.execFn()
+				}
+			})
+		})
+	}
+
+	_writeLegacyLogs (logs) {
+		const localLogStore = parseLogStoreValue(readLegacyStorage(this.storageKey)) || {
+			size: 0,
+			data: []
+		}
+		const allData = [].concat(logs, localLogStore.data)
+		const nextLocalStore = {
+			size: 0,
+			data: []
+		}
+		allData.some(item => {
+			const itemSize = getLogSize(item)
+			if (itemSize + nextLocalStore.size >= this.maxSize) {
+				return true
+			}
+			nextLocalStore.data.push(item)
+			nextLocalStore.size += itemSize
+			return false
+		})
+		writeLegacyStorage(this.storageKey, nextLocalStore)
+	}
+
+	checkAndSync () {
+		if (!this.useIndexedDb) {
+			return Promise.resolve({
+				synced: false,
+				migratedCount: 0,
+				duplicateCount: 0,
+				removedCount: 0
+			})
+		}
+		if (this._syncPromise) {
+			return this._syncPromise
+		}
+		const task = this._enqueueWrite(() => {
+			const legacyLogStore = parseLogStoreValue(readLegacyStorage(this.storageKey))
+			if (!legacyLogStore || !legacyLogStore.data.length) {
+				return {
+					synced: false,
+					migratedCount: 0,
+					duplicateCount: 0,
+					removedCount: 0
+				}
+			}
+			return this._writeIndexedDbLogs(legacyLogStore.data).then(result => {
+				removeLegacyStorage(this.storageKey)
+				return Object.assign({ synced: true }, result)
+			})
+		})
+		this._syncPromise = task.then(result => {
+			this._syncPromise = null
+			return result
+		}, () => {
+			this._syncPromise = null
+			return {
+				synced: false,
+				migratedCount: 0,
+				duplicateCount: 0,
+				removedCount: 0
+			}
+		})
+		return this._syncPromise
+	}
+
+	/**
+	 * 新增日志到内存
+	 */
+	addLog (data) {
+		data = Object.assign({
+			group: this.defautGroup,
+			refererId: undefined, // 可以关联一个日志
+			content: null
+		}, data, {
+			createTime: formatDate(new Date())
+		})
+		data.id = unique(data.group)
+		if (this.beforeAddCallback && this.beforeAddCallback({ data }) === false) {
+			return
+		}
+		data.size = JSON.stringify(data).length
+		this.tempStore.push(data)
+		this.checkAndSync().catch(() => {})
+		if (this.tempStore.length > 5) {
+			this.publishLogData().then(null, err => {
+				console.log(err)
+			})
+		}
+		if (this.options.console) {
+			console.log(`【${this.name || 'operateLog'}】${JSON.stringify(data) || '--'}`)
+		}
+		return data
+	}
+
+	/**
+	 * 清空本地日志
+	 */
+	clearLogData () {
+		this.tempStore = []
+		const task = this._enqueueWrite(() => {
+			if (!this.useIndexedDb) {
+				removeLegacyStorage(this.storageKey)
+				return
+			}
+			return this.openIndexedDb().then(db => {
+				return new Promise((resolve, reject) => {
+					const transaction = db.transaction(
+						[INDEXED_DB_STORE_NAME, INDEXED_DB_META_STORE_NAME],
+						'readwrite'
+					)
+					transaction.objectStore(INDEXED_DB_STORE_NAME).clear()
+					transaction.objectStore(INDEXED_DB_META_STORE_NAME).put({
+						key: INDEXED_DB_STATS_KEY,
+						totalBytes: 0,
+						nextOrder: 0
+					})
+					transaction.oncomplete = resolve
+					transaction.onerror = () => reject(transaction.error || new Error('清理日志失败'))
+					transaction.onabort = () => reject(transaction.error || new Error('清理日志失败'))
 				})
-    }
-
-    exportLogData () {
-        return this.publishLogData().then(() => {
-            return this.loadLogData()
-        })
-    }
-}
+			}).then(() => {
+				removeLegacyStorage(this.storageKey)
+			})
+		})
+		return task.catch(() => {
+			removeLegacyStorage(this.storageKey)
+		})
+	}
+
+	loadLogData () {
+		return this.checkAndSync().then(() => this._writePromise).then(() => {
+			if (this.useIndexedDb) {
+				return this._readIndexedDbLogData().catch(() => ({ size: 0, data: [] }))
+			}
+			return parseLogStoreValue(readLegacyStorage(this.storageKey)) || {
+				size: 0,
+				data: []
+			}
+		})
+	}
+
+	publishLogData () {
+		return this.checkAndSync().then(() => {
+			return this._enqueueWrite(() => {
+				if (!this.tempStore.length) {
+					return
+				}
+				const flushingTempStore = this.tempStore.slice()
+				this.tempStore = []
+				let writeTask
+				if (this.useIndexedDb) {
+					writeTask = this._writeIndexedDbLogs(flushingTempStore).catch(() => {})
+				} else {
+					writeTask = Promise.resolve().then(() => this._writeLegacyLogs(flushingTempStore))
+				}
+				return writeTask.catch(error => {
+					this.tempStore = flushingTempStore.concat(this.tempStore)
+					throw error
+				})
+			})
+		})
+	}
+
+	exportLogData () {
+		return this.checkAndSync().then(() => {
+			return this.publishLogData()
+		}).then(() => {
+			return this.loadLogData()
+		})
+	}
+}