@abtnode/util 1.8.25 → 1.8.27

package/lib/log.js

@@ -0,0 +1,250 @@
+/* eslint-disable no-underscore-dangle */
+const path = require('path');
+const fs = require('fs');
+const isEqual = require('lodash/isEqual');
+const { Tail } = require('tail');
+const readLastLines = require('read-last-lines');
+const { BLOCKLET_MODES } = require('@blocklet/constant');
+const logger = require('@abtnode/logger')(require('../package.json').name);
+
+class StreamLog {
+  constructor() {
+    this._files = null; // Object { <level>: <filePath> }
+    this._tails = null; // Object { <level>: <Tail> }
+  }
+
+  /**
+   * @param {Object} files Object { <level>: <filePath> }
+   * @return {Boolean} if files change
+   */
+  async setFiles(files) {
+    if (!isEqual(this._files, files)) {
+      this.clearTails();
+      this._files = files;
+      return true;
+    }
+    return false;
+  }
+
+  getRecent(lineNum, callback) {
+    if (!this._files) {
+      callback(new Error('files is empty'));
+    }
+    Object.entries(this._files).forEach(([level, file]) => {
+      if (!file || !fs.existsSync(file)) {
+        return;
+      }
+      readLastLines
+        .read(file, lineNum || 0)
+        .then((data) => {
+          callback(null, level, data);
+        })
+        .catch((error) => {
+          callback(error, level);
+        });
+    });
+  }
+
+  ensureTails() {
+    if (this._tails) {
+      return this._tails;
+    }
+    if (!this._files) {
+      return {};
+    }
+    try {
+      this._tails = {};
+      Object.entries(this._files).forEach(([level, file]) => {
+        if (!file || !fs.existsSync(file)) {
+          return;
+        }
+        this._tails[level] = new Tail(file);
+      });
+      return this._tails;
+    } catch (error) {
+      this._tails = null;
+      throw error;
+    }
+  }
+
+  clearTails() {
+    if (this._tails) {
+      Object.values(this._tails).forEach((tail) => {
+        tail.unwatch();
+      });
+      this._tails = null;
+    }
+  }
+}
+
+const createFile = (files) => {
+  Object.values(files).forEach((file) => {
+    if (!fs.existsSync(file)) {
+      try {
+        const dir = path.dirname(file);
+        fs.mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        // Do nothing
+      }
+      fs.writeFileSync(file, '', 'utf8');
+    }
+  });
+};
+
+const getLogFiles = async ({ name, node }) => {
+  const dt = new Date();
+  const { yyyy, mm, dd } = {
+    yyyy: dt.getFullYear(),
+    mm: `${dt.getMonth() + 1}`.padStart(2, 0),
+    dd: `${dt.getDate()}`.padStart(2, 0),
+  };
+  const date = `${yyyy}-${mm}-${dd}`;
+
+  if (name === 'abtnode') {
+    const logDir = path.join(node.dataDirs.logs, '_abtnode');
+
+    const info = path.join(logDir, `daemon-${date}.log`);
+    const error = path.join(logDir, `daemon-error-${date}.log`);
+    const access = path.join(logDir, 'access.log');
+    const stdout = path.join(logDir, 'daemon.stdout.log');
+    const stderr = path.join(logDir, 'daemon.stderr.log');
+
+    createFile({
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+    });
+
+    return {
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+    };
+  }
+
+  if (name === 'blocklet-services') {
+    const logDir = path.join(node.dataDirs.logs, '_abtnode');
+    const info = path.join(logDir, 'service.log');
+    const error = path.join(logDir, 'service.error.log');
+    createFile({ info, error });
+    return { info, error };
+  }
+
+  if (name.indexOf('blocklet-') === 0) {
+    const did = name.substring('blocklet-'.length);
+    const blocklet = await node.getBlocklet({ did, attachConfig: false });
+    const { name: blockletName } = blocklet.meta;
+
+    const dir = path.join(node.dataDirs.logs, blockletName);
+    const info = path.join(dir, `info-${date}.log`);
+    const error = path.join(dir, `info-error-${date}.log`);
+    const access = path.join(dir, 'access.log');
+    const stdout = path.join(dir, 'output.log');
+    const stderr = path.join(dir, 'error.log');
+
+    createFile({
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+    });
+
+    return {
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+      recent: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? 0 : 100,
+    };
+  }
+
+  if (name.startsWith('service-gateway-')) {
+    const providerName = name.substring('service-gateway-'.length);
+    const provider = node.getRouterProvider(providerName);
+    if (!provider) {
+      logger.error('router engine is empty', { name, providerName });
+      return {};
+    }
+
+    return provider.getLogFilesForToday(path.join(node.dataDirs.router, providerName));
+  }
+
+  return {};
+};
+
+const createStreamLogManager = ({ onLog, onGetLogFiles }) => {
+  const store = {}; // Object<name: streamLog>
+
+  const ensure = (name) => {
+    if (!store[name]) {
+      store[name] = new StreamLog();
+    }
+    return store[name];
+  };
+
+  const destroy = (name) => {
+    logger.info('log stream: destroy', { name });
+    if (!store[name]) {
+      return;
+    }
+    const log = store[name];
+    try {
+      log.clearTails();
+      delete store[name];
+    } catch (error) {
+      logger.error('log stream: remove ref error ', error);
+      delete store[name];
+    }
+  };
+
+  const add = async (name, topic, firstLogCb) => {
+    logger.info('log stream: add', { name });
+    const log = ensure(name);
+    try {
+      // update files
+      // push recent 100 log
+      const { recent = 100, ...logFiles } = await onGetLogFiles(name);
+      const changed = await log.setFiles(logFiles);
+      logger.info('log stream: added', { name, logFiles });
+      log.getRecent(recent, (error, level, data) => {
+        if (error) {
+          logger.error('log stream error ', error);
+        }
+        if (firstLogCb) {
+          firstLogCb(level, data, logFiles);
+        }
+      });
+      // stream
+      if (changed) {
+        const tails = log.ensureTails();
+        Object.entries(tails).forEach(([level, tail]) => {
+          tail.on('line', (data) => {
+            onLog({ topic, level, logFiles, data });
+          });
+          tail.on('error', (error) => {
+            logger.error('log tail error ', { error });
+            destroy(name);
+          });
+        });
+      }
+    } catch (error) {
+      logger.error('log stream error ', error);
+    }
+  };
+
+  return {
+    add,
+    destroy,
+  };
+};
+
+module.exports = {
+  createStreamLogManager,
+  getLogFiles,
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.25",
+  "version": "1.8.27",
   "description": "ArcBlock's JavaScript utility",
   "main": "lib/index.js",
   "files": [
@@ -18,12 +18,13 @@
   "author": "polunzh <polunzh@gmail.com> (http://github.com/polunzh)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/constant": "1.8.25",
-    "@abtnode/logger": "1.8.25",
-    "@arcblock/jwt": "^1.17.19",
-    "@ocap/mcrypto": "1.17.19",
-    "@ocap/util": "1.17.19",
-    "@ocap/wallet": "1.17.19",
+    "@abtnode/constant": "1.8.27",
+    "@abtnode/logger": "1.8.27",
+    "@arcblock/jwt": "^1.17.20",
+    "@blocklet/constant": "1.8.27",
+    "@ocap/mcrypto": "1.17.20",
+    "@ocap/util": "1.17.20",
+    "@ocap/wallet": "1.17.20",
     "axios": "^0.27.2",
     "axios-mock-adapter": "^1.21.2",
     "axon": "^2.0.3",
@@ -42,10 +43,12 @@
     "parallel-transform": "^1.2.0",
     "public-ip": "^4.0.4",
     "pump": "^3.0.0",
+    "read-last-lines": "^1.8.0",
     "semver": "^7.3.7",
     "semver-sort": "^1.0.0",
     "shelljs": "^0.8.5",
     "stream-to-promise": "^3.0.0",
+    "tail": "^2.2.4",
     "through2-filter": "^3.0.0",
     "through2-map": "^3.0.0",
     "to-semver": "^3.0.0",
@@ -58,5 +61,5 @@
     "fs-extra": "^10.1.0",
     "jest": "^27.5.1"
   },
-  "gitHead": "ea34dcd0037c63cb63b31744efcf169edf8aa776"
+  "gitHead": "84b2cb3ee703479f17e88c91650ecf3015cbf6af"
 }