lib: improve error creation performance

lib/_http_outgoing.js

@@ -445,20 +445,32 @@ function matchHeader(self, state, field, value) {
 
 function validateHeaderName(name) {
   if (typeof name !== 'string' || !name || !checkIsHttpToken(name)) {
+    // Reducing the limit improves the performance significantly. We do not
+    // lose the stack frames due to the `captureStackTrace()` function that is
+    // called later.
+    const tmpLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
     const err = new ERR_INVALID_HTTP_TOKEN('Header name', name);
+    Error.stackTraceLimit = tmpLimit;
     Error.captureStackTrace(err, validateHeaderName);
     throw err;
   }
 }
 
 function validateHeaderValue(name, value) {
   let err;
+  // Reducing the limit improves the performance significantly. We do not loose
+  // the stack frames due to the `captureStackTrace()` function that is called
+  // later.
+  const tmpLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
   if (value === undefined) {
     err = new ERR_HTTP_INVALID_HEADER_VALUE(value, name);
   } else if (checkInvalidHeaderChar(value)) {
     debug('Header "%s" contains invalid characters', name);
     err = new ERR_INVALID_CHAR('header content', name);
   }
+  Error.stackTraceLimit = tmpLimit;
   if (err !== undefined) {
     Error.captureStackTrace(err, validateHeaderValue);
     throw err;

lib/internal/errors.js

@@ -261,10 +261,16 @@ function uvException(ctx) {
     message += ` -> '${dest}'`;
   }
 
+  // Reducing the limit improves the performance significantly. We do not loose
+  // the stack frames due to the `captureStackTrace()` function that is called
+  // later.
+  const tmpLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
   // Pass the message to the constructor instead of setting it on the object
   // to make sure it is the same as the one created in C++
   // eslint-disable-next-line no-restricted-syntax
   const err = new Error(message);
+  Error.stackTraceLimit = tmpLimit;
 
   for (const prop of Object.keys(ctx)) {
     if (prop === 'message' || prop === 'path' || prop === 'dest') {
@@ -307,8 +313,14 @@ function uvExceptionWithHostPort(err, syscall, address, port) {
     details = ` ${address}`;
   }
 
+  // Reducing the limit improves the performance significantly. We do not loose
+  // the stack frames due to the `captureStackTrace()` function that is called
+  // later.
+  const tmpLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
   // eslint-disable-next-line no-restricted-syntax
   const ex = new Error(`${message}${details}`);
+  Error.stackTraceLimit = tmpLimit;
   ex.code = code;
   ex.errno = code;
   ex.syscall = syscall;
@@ -377,9 +389,15 @@ function exceptionWithHostPort(err, syscall, address, port, additional) {
     details += ` - Local (${additional})`;
   }
 
+  // Reducing the limit improves the performance significantly. We do not loose
+  // the stack frames due to the `captureStackTrace()` function that is called
+  // later.
+  const tmpLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
   // eslint-disable-next-line no-restricted-syntax
   const ex = new Error(`${syscall} ${code}${details}`);
   // TODO(joyeecheung): errno is supposed to err, like in uvException
+  Error.stackTraceLimit = tmpLimit;
   ex.code = ex.errno = code;
   ex.syscall = syscall;
   ex.address = address;
@@ -410,9 +428,15 @@ function dnsException(code, syscall, hostname) {
     }
   }
   const message = `${syscall} ${code}${hostname ? ` ${hostname}` : ''}`;
+  // Reducing the limit improves the performance significantly. We do not loose
+  // the stack frames due to the `captureStackTrace()` function that is called
+  // later.
+  const tmpLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
   // eslint-disable-next-line no-restricted-syntax
   const ex = new Error(message);
   // TODO(joyeecheung): errno is supposed to be a number / err, like in
+  Error.stackTraceLimit = tmpLimit;
   // uvException.
   ex.errno = code;
   ex.code = code;

lib/internal/fs/utils.js

@@ -190,23 +190,27 @@ function nullCheck(path, propName, throwError = true) {
   const pathIsUint8Array = isUint8Array(path);
 
   // We can only perform meaningful checks on strings and Uint8Arrays.
-  if (!pathIsString && !pathIsUint8Array) {
+  if (!pathIsString && !pathIsUint8Array ||
+      pathIsString && path.indexOf('\u0000') === -1 ||
+      pathIsUint8Array && path.indexOf(0) === -1) {
     return;
   }
 
-  if (pathIsString && path.indexOf('\u0000') === -1) {
-    return;
-  } else if (pathIsUint8Array && path.indexOf(0) === -1) {
-    return;
+  // Reducing the limit improves the performance significantly. We do not loose
+  // the stack frames due to the `captureStackTrace()` function that is called
+  // later.
+  const tmpLimit = Error.stackTraceLimit;
+  if (throwError) {
+    Error.stackTraceLimit = 0;
   }
-
   const err = new ERR_INVALID_ARG_VALUE(
     propName,
     path,
     'must be a string or Uint8Array without null bytes'
   );
 
   if (throwError) {
+    Error.stackTraceLimit = tmpLimit;
     Error.captureStackTrace(err, nullCheck);
     throw err;
   }

lib/internal/process/warning.js

@@ -127,8 +127,13 @@ function setupProcessWarnings() {
       throw new ERR_INVALID_ARG_TYPE('code', 'string', code);
     }
     if (typeof warning === 'string') {
+      // Improve error creation performance by skipping the error frames.
+      // They are added in the `captureStackTrace()` function below.
+      const tmpStackLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
       // eslint-disable-next-line no-restricted-syntax
       warning = new Error(warning);
+      Error.stackTraceLimit = tmpStackLimit;
       warning.name = String(type || 'Warning');
       if (code !== undefined) warning.code = code;
       if (detail !== undefined) warning.detail = detail;