Node.js 如何在nextTick中登录？

我正在调试一个导致堆栈跟踪丢失的问题

我希望能够从

nextTick

中登录

const _nextTick = process.nextTick;

process.nextTick = function (callback) {
  process.stdout.write('bar');

  const args = Array.prototype.slice.call(arguments);

  return _nextTick.apply(this, args);
};

console.log('foo');

但是，这会导致

超过最大调用堆栈大小

错误

RangeError: Maximum call stack size exceeded
    at process.nextTick (/Users/gajus/Documents/dev/applaudience/showtime-api/test.js:4:10)
    at onwrite (_stream_writable.js:372:15)
    at WriteStream.Socket._writeGeneric (net.js:727:5)
    at WriteStream.Socket._write (net.js:737:8)
    at doWrite (_stream_writable.js:329:12)
    at writeOrBuffer (_stream_writable.js:315:5)
    at WriteStream.Writable.write (_stream_writable.js:241:11)
    at WriteStream.Socket.write (net.js:664:40)
    at process.nextTick (/Users/gajus/Documents/dev/applaudience/showtime-api/test.js:4:18)
    at onwrite (_stream_writable.js:372:15)

似乎

\u stream\u writable.js

在内部使用了

nextTick

，这导致了无限循环：

foo
barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar/Users/gajus/Documents/dev/applaudience/showtime-api/test.js:4
  process.stdout.write('bar');

---

是否有比

process.stdout.write

更低的级别可以用来从

nextTick

中记录消息？

我能想到的唯一解决方案是创建一个数组，跟踪我要记录的消息，并以设定的间隔将它们发送到

stdout

const _nextTick = process.nextTick;

let logs = [];
let intervalSeen = false;

process.nextTick = function (callback) {
  if (intervalSeen) {
    logs = [];

    intervalSeen = false;
  }

  logs.push('bar');

  const args = Array.prototype.slice.call(arguments);

  return _nextTick.apply(this, args);
};

setInterval(() => {
  intervalSeen = true;

  console.log(logs);
}, 500)

console.log('foo');

请试试这个：

var fs = require('fs')
const _nextTick = process.nextTick;
var stream = fs.createWriteStream('blah', {fd: 1})

process.nextTick = function (callback) {
  stream.write('bar')
  const args = Array.prototype.slice.call(arguments)
  return _nextTick.apply(this, args)
}
console.log('foo')

---

您不能用其他东西全局替换

.nextTick（）

，而期望使用它的广泛代码仍能工作。不管你想解决什么问题，那都不是一个好办法。如果您想要一个可以使用该日志的nextTick版本，那么就创建自己的函数来记录和调用nextTick，并在代码中使用该新函数。不要替换系统的nextTick。替换

nextTick

（以及其他

进程

和事件处理程序）以捕获长堆栈跟踪是捕获异步操作堆栈跟踪的标准（唯一）方法。请参阅以供参考。