![Introducing Enhanced Alert Actions and Triage Functionality](https://cdn.sanity.io/images/cgdhsj6q/production/fe71306d515f85de6139b46745ea7180362324f0-2530x946.png?w=800&fit=max&auto=format)
Product
Introducing Enhanced Alert Actions and Triage Functionality
Socket now supports four distinct alert actions instead of the previous two, and alert triaging allows users to override the actions taken for all individual alerts.
raven
Advanced tools
Readme
Node v0.10 compatible
Log errors and stack traces in Sentry from within your Node.js applications. Includes middleware support for Connect/Express.
All processing and sending happens asynchronously to not slow things down if/when Sentry is down or slow.
Raven 0.6+ requires Sentry 6.0+
$ npm install raven
var raven = require('raven');
var client = new raven.Client('{{ SENTRY_DSN }}');
client.captureMessage('Hello, world!');
client.captureError(new Error('Broke!'));
client.captureQuery('SELECT * FROM `awesome`', 'mysql');
client.captureMessage('Hello, world!', function(result) {
console.log(client.getIdent(result));
});
client.captureError(new Error('Broke!'), function(result) {
console.log(client.getIdent(result));
});
Note: client.captureMessage
will also return the result directly without the need for a callback, such as: var result = client.captureMessage('Hello, world!');
If you really care if the event was logged or errored out, Client emits two events, logged
and error
:
client.on('logged', function(){
console.log('Yay, it worked!');
});
client.on('error', function(e){
console.log('oh well, Sentry is broke.');
})
client.captureMessage('Boom');
The event error is augmented with the original Sentry response object as well as the response body and statusCode for easier debugging.
client.on('error', function(e){
console.log(e.reason); // raw response body, usually contains a message explaining the failure
console.log(e.statusCode); // status code of the http request
console.log(e.response); // entire raw http response object
});
Optionally declare the DSN to use for the client through the environment. Initializing the client in your app won't require setting the DSN.
Optionally set the name for the client to use. What is name?
Optionally set the site for the client to use. What is site?
For those times when you don't catch all errors in your application. ;)
client.patchGlobal();
// or
raven.patchGlobal(client);
// or
raven.patchGlobal('{{ SENTRY_DSN }}');
It is recommended that you don't leave the process running after receiving an uncaughtException
(http://nodejs.org/api/process.html#process_event_uncaughtexception), so an optional callback is provided to allow you to hook in something like:
client.patchGlobal(function() {
console.log('Bye, bye, world.')
process.exit(1);
});
The callback is called after the event has been sent to the Sentry server.
new raven.Client(dsn[, options])
client.captureMessage(string[,callback])
client.captureError(Error[,callback])
client.captureQuery(string, string[,callback])
The Raven middleware can be used as-is with either Connect or Express in the same way. Take note that in your middlewares, Raven must appear after your main handler to pick up any errors that may result from handling a request.
var connect = require('connect');
function mainHandler(req, res) {
throw new Error('Broke!');
}
function onError(err, req, res, next) {
// The error id is attached to `res.sentry` to be returned
// and optionally displayed to the user for support.
res.statusCode = 500;
res.end(res.sentry+'\n');
}
connect(
connect.bodyParser(),
connect.cookieParser(),
mainHandler,
raven.middleware.connect('{{ SENTRY_DSN }}'),
onError, // optional error handler if you want to display the error id to a user
).listen(3000);
var app = require('express')();
app.use(app.router);
app.use(raven.middleware.express('{{ SENTRY_DSN }}'));
app.use(onError); // optional error handler if you want to display the error id to a user
app.get('/', function mainHandler(req, res) {
throw new Error('Broke!');
});
app.listen(3000);
Note: raven.middleware.express
or raven.middleware.connect
must be added to the middleware stack before any other error handling middlewares or there's a chance that the error will never get to Sentry.
In order to use raven-node with coffee-script or another library which overwrites Error.prepareStackTrace you might run into the exception "Traceback does not support Error.prepareStackTrace being defined already."
In order to not have raven-node (and the underlying raw-stacktrace library) require Traceback you can pass your own stackFunction in the options. For example:
var client = new raven.Client('{{ SENTRY_DSN }}', { stackFunction: {{ Your stack function }}});
So for example:
var client = new raven.Client('{{ SENTRY_DSN }}', {
stackFunction: Error.prepareStackTrace
});
Pass false
as the DSN (or any falsey value).
client = new raven.Client(process.env.NODE_ENV === 'production' && '{{ SENTRY_DSN }}')
Note: We don't infer this from NODE_ENV
automatically anymore. It's up to you to implement whatever logic you'd like.
You can find me on IRC. I troll in #sentry
on freenode
.
FAQs
A standalone (Node.js) client for Sentry
We found that raven demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 10 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Product
Socket now supports four distinct alert actions instead of the previous two, and alert triaging allows users to override the actions taken for all individual alerts.
Security News
Polyfill.io has been serving malware for months via its CDN, after the project's open source maintainer sold the service to a company based in China.
Security News
OpenSSF is warning open source maintainers to stay vigilant against reputation farming on GitHub, where users artificially inflate their status by manipulating interactions on closed issues and PRs.