exports.register = (server, options, next) => {
const dsn = options.dsn;
const client = new Raven.Client(dsn, options.client);
if (dsn && options.patchGlobal) {
client.patchGlobal((err) => {
/* $lab:coverage:off$ */
console.error(err);
process.exit(1);
/* $lab:coverage:on$ */
});
}
server.expose('raven', client);
server.on('request-error', (request, err) => {
client.captureError(err, {
extra: {
timestamp: request.info.received,
id: request.id,
method: request.method,
path: request.path,
query: request.query,
remoteAddress: request.info.remoteAddress,
userAgent: request.raw.req.headers['user-agent']
}
});
});
return next();
};
function init() {
if (!isDev) {
const raven = require('raven');
ravenClient = new raven.Client('https://*****:*****@sentry.io/101586');
ravenClient.patchGlobal();
}
}
constructor(clientOptions, context, microkit) {
this.reportTimeout = clientOptions.timeout || 5000;
this.logger = microkit.logger.create('raven');
this.client = new raven.Client(clientOptions.url, clientOptions.transport);
this.client.setExtraContext(context);
this.client.on('error', error => {
this.logger.error('cannot capture error', error);
});
}
function initClient(sentryDSN, options) {
if (options === void 0) { options = {}; }
if (!sentryDSN) {
return;
}
client = new raven.Client(sentryDSN, options);
client.patchGlobal(function (status, e) {
console.error('Uncaught Exception', e, e.stack);
process.exit(1);
});
}
return new Promise((res, rej) => {
const onLogged = () => {
res();
};
const onError = err => {
rej(err);
};
this.client.once('logged', onLogged);
this.client.once('error', onError);
this.client.captureError(error, context);
}).timeout(this.reportTimeout);
app.use(function(req, res) {
client.captureError(new Error('Page Not Found'));
res.status(404).render('404', {
url: req.originalUrl,
error: 'Not Found'
});
});
stream.on('error', function (err, statusCode) {
statusCode = statusCode || 200;
console.log("ntwitter.stream Error: " + err + " StatusCode: " + statusCode + " on twitter account: '" + that.twitter_consumer_key + "'");
sentry.captureError("ntwitter.stream Error: " + JSON.stringify(err) + " StatusCode: " + statusCode,
{extra: {subjects: JSON.stringify(that.subjects), statusCode: statusCode, twitter_account: that.twitter_consumer_key}});
//try to reconnect if we get an rate limit error
if (statusCode === 420 || statusCode === 429 || statusCode === 401) {
//we want to keep the previous stream active and kill this one
if (that.activeStream === stream) { that.activeStream = null; }
stream.destroy();
that.errorReconnectTimeoutId = setTimeout(function() {
console.log("Attempting to reconnect to twitter after rate limit error");
sentry.captureError("Attempting to reconnect to twitter after rate limit error",
{level: 'info', extra: {subjects: JSON.stringify(that.subjects), twitter_account: that.twitter_consumer_key}});
that.errorReconnectTimeoutId = null;
that.ntwitterConnect();
}, 30000); //30 secs
}
//try to reconnect if we get a server error
if (statusCode === 501 || statusCode === 503 || statusCode === 504) {
//we want to keep the previous stream active and kill this one
if (that.activeStream === stream) { that.activeStream = null; }
stream.destroy();
that.errorReconnectTimeoutId = setTimeout(function() {
console.log("Attempting to reconnect to twitter after server error");
sentry.captureError("Attempting to reconnect to twitter after server error",
{level: 'error', extra: {subjects: JSON.stringify(that.subjects), twitter_account: that.twitter_consumer_key}});
that.errorReconnectTimeoutId = null;
that.ntwitterConnect();
}, 10000); //10 secs
}
});
setUser( user ) {
if( this._client ) {
this._client.setUserContext(user);
}
return this;
}
}, persister, function(err, uri) {
const responsePayload = {
task: payload.task,
page: {
page_number: payload.page.page_number,
atlas: {
slug: payload.page.atlas.slug
}
}
};
if (err) {
console.warn(err.stack);
sentry.captureError(err);
responsePayload.error = {
message: err.message,
stack: err.stack
};
} else {
responsePayload.page.pdf_url = uri;
}
return callback(null, responsePayload);
});
client.query(command.text, command.values, function(err, result) {
done(); //relase client back ot the connection pool
if (err) {
sentry.captureError("PG Error: Failed to store received tweet with error:" + err);
return console.error('PG Error: Failed to store received tweet with error', err);
}
});
pg.connect(connStr, function(err, client, done) {
if (err) {
sentry.captureError("PG Error fetching client from pool" + err);
return console.error('PG Error fetching client from pool', err);
}
var command =
filtered_tweets.insert({
channel: subject,
was_emitted: was_emitted,
rejected_reason: reject_reason,
filtered_at: new Date(),
created_at: created_at,
sender: sender,
tweet_id: tweet_id,
source: source,
json_value: JSON.stringify(tweet)
}).toQuery();
client.query(command.text, command.values, function(err, result) {
done(); //relase client back ot the connection pool
if (err) {
sentry.captureError("PG Error: Failed to store received tweet with error:" + err);
return console.error('PG Error: Failed to store received tweet with error', err);
}
});
});
setTags( tags ) {
if( this._client ) {
this._client.setTagsContext(tags);
}
return this;
}
db.collection('logs').insert(message, function (error) {
if (error) {
sentry.captureError(error, function (result) {
console.log(sentry.getIdent(result));
});
}
});
export default function handleError(handle) {
if (!handle) {
throw new Error('Null error returned')
}
// if used for callback
if (typeof handle == 'function') {
return function(err, ...args) {
if (err) {
console.error('ERROR'.red, err)
process.exit(1)
return
}
handle && handle(...args)
}
}
// if used in try/catch
else {
// TODO type this
const error = handle
if (!error) return print(' No error!')
errorClient.captureException(error)
error.message = unicodeToChar(error.message)
error.stack = unicodeToChar(error.stack || error.codeFrame)
logError(error)
bridge.broadcast('compile:error', { error }, 'error')
}
}
test('basic', function(done) {
var scope = nock('https://app.getsentry.com')
.filteringRequestBody(/.*/, '*')
.post('/api/store/', '*')
.reply(200, function(uri, body) {
zlib.inflate(new Buffer(body, 'base64'), function(err, buff) {
var msg = JSON.parse(buff.toString());
assert.ok(msg['sentry.interfaces.Http']);
assert.equal(msg.message, 'Error: foobar');
var http = msg['sentry.interfaces.Http'];
assert.equal(http.method, 'GET');
assert.equal(http.headers.host, 'localhost:3000');
assert.equal(http.url, 'http://localhost:3000/');
});
done();
});
client.on('logged', function() {
scope.done();
});
request('http://localhost:3000');
});
setExtra( extra ) {
if( this._client ) {
this._client.setExtraContext(extra);
}
return this;
}
return function(event, context, callback) {
db_connection.connect()
try {
var v = fn(event, db_connection, context, callback)
if (v && typeof v.then == 'function') {
v.then(val => {
callback(null, val)
db_connection.end()
}).catch(err => {
console.error(err.stack)
sentryClient.captureException(err)
callback(err)
})
return
}
// This is the non-promise logic, but should be able to remove this branch and do both the same way
callback(null, v)
db_connection.end()
} catch (err) {
console.error(err.stack)
sentryClient.captureException(err)
callback(err)
}
}
that.errorReconnectTimeoutId = setTimeout(function() {
console.log("Attempting to reconnect to twitter after server error");
sentry.captureError("Attempting to reconnect to twitter after server error",
{level: 'error', extra: {subjects: JSON.stringify(that.subjects), twitter_account: that.twitter_consumer_key}});
that.errorReconnectTimeoutId = null;
that.ntwitterConnect();
}, 10000); //10 secs
exports.sentry = function (sentryConfig, params) {
var sentryClient = new raven.Client(sentryConfig.serverDSN, params);
return function sentryLogger(err, req) {
// https://github.com/getsentry/raven-node/blob/0.12.0/lib/middleware/connect.js#L21-L25
var kwargs = req ? ravenParsers.parseRequest(req) : {};
sentryClient.captureError(err, kwargs);
};
};
exports.report = function(error) {
try {
if(typeof error == "object") {
if((Array.isArray(error) && !error.empty) || !$.isEmptyObject(error)) {
console.error(error);
client.captureError(error);
}
} else if(error) {
console.error(error.code);
console.error(error);
client.captureError(error);
}
} catch(error) {
return exports.report(error);
}
}
db.update(req.params.id, req.body, function (err, c) {
if (err) {
client.captureError(err);
}
db.getStats(function (err2, planes) {
res.json(planes);
});
});
SupinBot.log.exitOnError = (err) => {
if (_exitOnError) _exitOnError(err);
client.captureError(err, (res) => {
setTimeout(() => {
process.exit(1);
}, 3000);
});
};
db.getPlane(req.params.id, true, function (err, p) {
if (err) {
client.captureError(err);
}
if (p) {
p.name = req.body.name;
delete req.body.name;
Promise.all([
plane.createPDF(fs.createWriteStream(__dirname + '/pdf/' + SERVER_PREFIX + '/' + p._id + '-print.pdf'), p, {
mergePdf: true,
texturePage: true,
cutPage: false
}),
plane.createPDF(fs.createWriteStream(__dirname + '/pdf/' + SERVER_PREFIX + '/' + p._id + '-cut.pdf'), p, {
mergePdf: false,
texturePage: false,
cutPage: true
}),
plane.createPDF(fs.createWriteStream(__dirname + '/pdf/' + SERVER_PREFIX + '/' + p._id + '-merged.pdf'), p, {
mergePdf: true,
texturePage: true,
cutPage: true
})
])
.then(function () {
if (process.env.PRINTER && process.env.FOXIT_LOCATION) {
childProcess.spawn(process.env.FOXIT_LOCATION, ['/t', __dirname + '/pdf/' + SERVER_PREFIX + '/' + p._id + '-print.pdf', process.env.PRINTER], {
stdio: 'ignore'
});
res.end('print');
}
else {
res.end('print@home');
}
db.update(p._id, {
printState: 2,
printDate: new Date(),
name: p.name,
info: req.body
}, function (err, r) {
if (err) {
client.captureError(err);
}
});
p.info = req.body;
if (req.body.email) {
isOnline(function (err, isOnline) {
if (isOnline) {
sendmail(p);
}
});
}
});
}
else {
res.sendStatus(404);
}
});
connection.when('available', function (err, _db) {
if (err) {
sentry.captureError(err, function (result) {
console.log(sentry.getIdent(result));
});
} else {
db = _db;
}
});
function init(config) {
const finalConfig = _.defaultsDeep(config, defaultConfig);
const loggerName = finalConfig.logger.name;
const loggerLevel = finalConfig.logger.level;
const loggerConfig = {
name: loggerName,
level: loggerLevel,
streams: [],
serializers: {
err: serializers.err,
},
};
if (finalConfig.logger.pretty) {
const prettyStdOut = new PrettyStream();
prettyStdOut.pipe(process.stdout);
loggerConfig.streams.push({
type: 'raw',
level: loggerLevel,
stream: prettyStdOut,
});
} else if (finalConfig.logger.hideSensitiveData) {
loggerConfig.streams.push({
level: loggerLevel,
stream: new SensitiveDataStream(finalConfig.logger.sensitiveDataPattern),
});
} else {
loggerConfig.streams.push({ level: loggerLevel, stream: process.stdout });
}
if (finalConfig.sentry && finalConfig.sentry.dsn) {
const client = new raven.Client(finalConfig.sentry.dsn, {
name: loggerName,
release: finalConfig.sentry.release,
environment: finalConfig.sentry.environment,
});
client.install();
loggerConfig.streams.push(sentryStream(client));
}
return bunyan.createLogger(loggerConfig);
}
db.getNextId(SERVER_PREFIX, function (err, autoIndex) {
if (err) {
client.captureError(err);
}
req.body._id = SERVER_PREFIX + '-' + autoIndex;
req.body.previewCount = 1;
db.savePlane(req.body, function (err, result) {
res.end(req.body._id);
});
});
this.pusher.trigger(channel, event, data, null, function(err, req, res) {
if (err) {
console.log("Could not emit event on Pusher API.", err);
sentry.captureError("Failed to emit Pusher event with error: " + err,
{extra: {channel: channel, data: JSON.stringify(data), twitter_account: that.twitter_consumer_key}});
}
else {
//console.log("Emitted tweet about " + subject + ": " + tweet.text)
}
});
function create({ravenConnectionString}) {
const client = new raven.Client(ravenConnectionString);
// TODO: Make an unpatcher wrapped in a return destroy function. -MANI
client.patchGlobal();
function info() {}
function warning() {}
function error(err) {
client.captureException(err)
}
return {
info,
warning,
error
}
}
app.use(function(err, req, res, next) {
// If the error object doesn't exists
if (!err) return next();
// Log it
console.error(err.stack);
client.captureError(err);
// Error page
res.status(500).render('500', {
error: err.stack
});
});
function setUser (user) {
if (user) {
currentUser = {
id: user._id,
email: user.email,
name: user.name
};
} else {
currentUser = undefined;
}
client.setUserContext(currentUser);
}