How can I rethrow an error or exception in nodejs/javascript and include a custom message.
I have the following code
var json = JSON.parse(result);
and I wanted to include the result content in the exception message should any parsing error occurs. Something like this.
1. try {
2. var json = JSON.parse(result);
3. expect(json.messages.length).to.be(1);
4. } catch(ex) {
5. throw new Error(ex.message + ". " + "JSON response: " + result);
6. }
The problem here is that I lose my stack trace.
Is there a way to do it similar to java?
throw new Error("JSON response: " + result, ex);
I'm not aware of a native method like Java's and I've not found an elegant solution for wrapping errors yet.
The problem with creating a new Error is you can lose metadata that was attached to the original Error that was thrown, the stack and type are generally the items are lost.
Making modifications to an existing thrown error is quicker, but it is still possible to modify data from the error out of existence. It also feels wrong to be poking around in an error that was created somewhere else.
Create a new Error and new stack
The .stack property of a new Error is a plain string and can be modified to say what you like before it is thrown. Replacing an errors stack property completely can get really confusing for debugging though.
When the original thrown error and the error handler are in separate locations or files (which is common with promises), you might be able to trace the source of the original error but not trace the handler where the error was actually trapped. To avoid this it's good to keep some references to both the original and new error in the stack. It's also useful to have access to the complete original error if there was additional metadata stored in it.
Here's an example of catching an error, wrapping it in a new error but adding the original stack and storing the error:
try {
throw new Error('First one')
} catch (error) {
let e = new Error(`Rethrowing the "${error.message}" error`)
e.original = error
e.stack = e.stack.split('\n').slice(0,2).join('\n') + '\n' +
error.stack
throw e
}
Which throws:
/so/42754270/test.js:9
throw e
^
Error: Rethrowing the "First one" error
at test (/so/42754270/test.js:5:13)
Error: First one
at test (/so/42754270/test.js:3:11)
at Object.<anonymous> (/so/42754270/test.js:13:1)
at Module._compile (module.js:570:32)
at Object.Module._extensions..js (module.js:579:10)
at Module.load (module.js:487:32)
at tryModuleLoad (module.js:446:12)
at Function.Module._load (module.js:438:3)
at Module.runMain (module.js:604:10)
at run (bootstrap_node.js:394:7)
at startup (bootstrap_node.js:149:9)
So we've created a new generic Error. Unfortunately the type of the original error becomes hidden from the output but the error has been attached as .original so it can still be accessed. The new stack has been largely removed except for the generating line which is important, and the original errors stack appended.
Any tools that try to parse stack traces might not work with this change or best case, they detect two errors.
ES2015 Error Classes
Making this into a reusable ES2015+ Error class...
// Standard error extender from @deployable/errors
class ExtendedError extends Error {
constructor(message){
super(message)
this.name = this.constructor.name
this.message = message
if (typeof Error.captureStackTrace === 'function'){
Error.captureStackTrace(this, this.constructor)
} else {
this.stack = (new Error(message)).stack
}
}
}
class RethrownError extends ExtendedError {
constructor(message, error){
super(message)
if (!error) throw new Error('RethrownError requires a message and error')
this.original = error
this.new_stack = this.stack
let message_lines = (this.message.match(/\n/g)||[]).length + 1
this.stack = this.stack.split('\n').slice(0, message_lines+1).join('\n') + '\n' +
error.stack
}
}
throw new RethrownError(`Oh no a "${error.message}" error`, error)
Results in
/so/42754270/test2.js:31
throw new RethrownError(`Oh no a "${error.message}"" error`, error)
^
RethrownError: Oh no a "First one" error
at test (/so/42754270/test2.js:31:11)
Error: First one
at test (/so/42754270/test2.js:29:11)
at Object.<anonymous> (/so/42754270/test2.js:35:1)
at Module._compile (module.js:570:32)
at Object.Module._extensions..js (module.js:579:10)
at Module.load (module.js:487:32)
at tryModuleLoad (module.js:446:12)
at Function.Module._load (module.js:438:3)
at Module.runMain (module.js:604:10)
at run (bootstrap_node.js:394:7)
at startup (bootstrap_node.js:149:9)
Then you know that whenever you see a RethrownError that the original error will still be available at .original.
This method is not perfect but it means I can re type known errors from underlying modules into generic types that be handled more easily, usually with bluebirds filtered catch .catch(TypeError, handler)
Same Error with a modified stack
Some times you will need to keep the original error mostly as is.
In this case you can just append/insert the new info onto existing stack.
file = '/home/jim/plumbers'
try {
JSON.parse('k')
} catch (e) {
let message = `JSON parse error in ${file}`
let stack = new Error(message).stack
e.stack = e.stack + '\nFrom previous ' + stack.split('\n').slice(0,2).join('\n') + '\n'
throw e
}
Which returns
/so/42754270/throw_error_replace_stack.js:13
throw e
^
SyntaxError: Unexpected token k in JSON at position 0
at Object.parse (native)
at Object.<anonymous> (/so/42754270/throw_error_replace_stack.js:8:13)
at Module._compile (module.js:570:32)
at Object.Module._extensions..js (module.js:579:10)
at Module.load (module.js:487:32)
at tryModuleLoad (module.js:446:12)
at Function.Module._load (module.js:438:3)
at Module.runMain (module.js:604:10)
at run (bootstrap_node.js:394:7)
at startup (bootstrap_node.js:149:9)
From previous Error: JSON parse error in "/home/jim/plumbers"
at Object.<anonymous> (/so/42754270/throw_error_replace_stack.js:11:20)
Also note that the stack processing is simple and assumes the error message is a single line. If you run into multi line error messages you might need to look for \n at to terminate the message.
If all you want to do is change the message, you can just change the message:
try {
throw new Error("Original Error");
} catch(err) {
err.message = "Here is some context -- " + err.message;
throw err;
}you can also just continue to throw the error up your try chain. If you want to modify anything do so along the way: before the throw statement in b.
function a() {
throw new Error('my message');
}
function b() {
try {
a();
} catch (e) {
// add / modify properties here
throw e;
}
}
function c() {
try {
b();
} catch (e) {
console.log(e);
document.getElementById('logger').innerHTML = e.stack;
}
}
c();<pre id="logger"></pre>来源：https://stackoverflow.com/questions/42754270/re-throwing-exception-in-nodejs-and-not-losing-stack-trace