const convertOpValue = async (identifier, { authInfo } = {}) => { const organisation = getOrgFromAuthInfo(authInfo); const personaService = getService(); const filter = { key: identifier.key.replace('persona.import.', ''), value: identifier.value }; // todo, check when actually exsits. let attributes; try { // TODO: change to use non connection api. const result = await personaService.getAttributes({ filter, organisation, limit: Number.MAX_SAFE_INTEGER, maxTimeMS: MAX_TIME_MS, maxScan: MAX_SCAN }); attributes = map(result.edges, ({ node }) => node); } catch (err) { logger.error('convert$personaIdent', err); return; } return { $in: without(map(attributes, ({ personaId }) => personaId), undefined, null) }; };
export default async ({ organisationId, emailType }, jobDone) => { // get all users in an org const users = await Users.find({ organisations: { $in: [organisationId] } }).exec(); const organisation = await Organisation.findById(organisationId); try { await map(users, async (user) => { // send the email if (emailType === WEEK_BEFORE_NOTIFICATION) { await sendOrganisationAboutToExpire(user, organisation); } else if (emailType === EXPIRATION_NOTIFICATION) { await sendOrganisationExpired(user, organisation); } }); } catch (err) { logger.error(err); } if (emailType === WEEK_BEFORE_NOTIFICATION) { organisation.expirationNotifications.weekBeforeNotificationSent = EMAIL_SENT; } else if (emailType === EXPIRATION_NOTIFICATION) { organisation.expirationNotifications.expirationNotificationSent = EMAIL_SENT; } await organisation.save(); jobDone(); };
sqs.purgeQueue({ QueueUrl: queueUrl }, (err) => { if (err) { logger.error('FAILED to purge queue', err); return reject(err); } return resolve(); })
toInterpolationContext: function (err) { // For data returned by backend, see // https://github.com/mozilla/fxa-auth-server/blob/master/error.js try { if (this.is(err, 'INVALID_PARAMETER')) { return { param: err.param || err.validation.keys }; } else if (this.is(err, 'MISSING_PARAMETER')) { return { param: err.param }; } else if (this.is(err, 'INVALID_RESUME_TOKEN_PROPERTY')) { return { property: err.property }; } else if (this.is(err, 'MISSING_RESUME_TOKEN_PROPERTY')) { return { property: err.property }; } } catch (e) { // handle invalid/unexpected data from the backend. logger.error('Error in errors.js->toInterpolationContext: %s', String(e)); } return {}; }
captureError: function (error, sentryMetrics, metrics, win) { var logger = new Logger(win); logger.error(error); sentryMetrics.captureException(error); if (metrics) { metrics.logError(error); } },
}, (err) => { if (err) { logger.error(`FAILED sending statement ${updatedStatement._id} to ${STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE}`, err); done(err); throw new Error('Error publishing to queue'); } done(); return; });
export const addStatementToPendingQueues = (statement, passedQueues, done) => { const queues = passedQueues || queueDependencies; if (!statement) { logger.error('No statement provided'); return done(); } const queueNames = keys(queues); const pendingQueueNames = reject(queueNames, (queueName) => { const queue = queues[queueName]; const completedQueues = statement.completedQueues || []; const processingQueues = statement.processingQueues || []; const intersectionQueues = intersection(queue.preReqs, completedQueues); // are the preReqs a subset of the queues which have already been completed? const preReqsCompleted = intersectionQueues.length === queue.preReqs.length; // or is this queue in the completed queues? const queueCompleted = includes(completedQueues, queueName); // or is this queue in the queues being processed? const queueProcessing = includes(processingQueues, queueName); return !preReqsCompleted || queueCompleted || queueProcessing; }); return Statement.updateOne( { _id: statement._id }, { $addToSet: { processingQueues: { $each: pendingQueueNames } } }, (err) => { if (err) return done(err); // adding to queue returns a promise // turns queue names into a stream of promises // call done when they have all completed return highland(pendingQueueNames).flatMap((queueName) => { logger.debug('ADDING STATEMENT TO QUEUE', queueName); const response = Queue.publish({ queueName, payload: { statementId: statement._id }, opts: { lifo: true } }); return highland(response); }).apply(() => { if (size(pendingQueueNames) > 0) { logger.debug(`ADDED ${statement._id} to ${pendingQueueNames.join(', ')}`); } else { logger.debug(`PROCESSED QUEUE FOR STATEMENT ${statement._id}`); } return done(); }); } ); };
async (err) => { const statement = await Statement.findOne(idFilter) .select({ _id: 1, completedQueues: 1, processingQueues: 1 }) .lean(); if (err) logger.error('Statement update error', err); if (err) return jobDone(err); // get the statement so that we can find which queues it has already been through return addStatementToPendingQueues(statement, queueDependencies, (err) => { if (err) logger.error('addStatementToPendingQueues error', err); if (jobDone) return jobDone(err); }); }
captureError: function (error, sentryMetrics, metrics, win) { var logger = new Logger(win); logger.error(error); // Ensure the message is interpolated before sending to // sentry and metrics. error.message = this.getErrorMessage(error); sentryMetrics.captureException(error); if (metrics) { metrics.logError(error); } },
export default async (model, organisation) => { const pathsBatch = QueryBuilderCache.collection.initializeUnorderedBulkOp(); const valuesBatch = QueryBuilderCacheValue.collection.initializeUnorderedBulkOp(); const caches = getCachesFromStatement(model); saveCachePaths(caches, organisation, pathsBatch); saveCacheValues(caches, organisation, valuesBatch); try { await Promise.all([ pathsBatch.execute({ w: 0 }), // write concern set to 0 to supress warnings of duplicate key errors valuesBatch.execute({ w: 0 }) // these are expected, letting mongo assert the uniqueness is the fastest way ]); } catch (err) { logger.error(err); } };
export default ({ status, statementId }, jobDone) => { try { if (status) { logger.debug(`COMPLETED ${statementId} - ${status}`); const idFilter = { _id: statementId }; return Statement.updateOne( idFilter, { $addToSet: { completedQueues: status }, $pull: { processingQueues: status } }, async (err) => { const statement = await Statement.findOne(idFilter) .select({ _id: 1, completedQueues: 1, processingQueues: 1 }) .lean(); if (err) logger.error('Statement update error', err); if (err) return jobDone(err); // get the statement so that we can find which queues it has already been through return addStatementToPendingQueues(statement, queueDependencies, (err) => { if (err) logger.error('addStatementToPendingQueues error', err); if (jobDone) return jobDone(err); }); } ); } logger.debug(`NO STATUS, statementId: ${statementId}`); return Statement.findById( statementId, { _id: 1, completedQueues: 1, processingQueues: 1 }, (err, statement) => { addStatementToPendingQueues(statement, queueDependencies, (err) => { if (err) logger.error('addStatementToPendingQueues error', err); if (jobDone) return jobDone(err); }); } ); } catch (err) { logger.error('statementHandler error', err); if (jobDone) jobDone(err); } };
const handleStatement = personaService => async (statement) => { const ifi = getIfiFromActor(statement.statement.actor); // This will only apply to the persona if they are created const personaName = statement.statement.actor.name ? statement.statement.actor.name : getIfiDisplayName(ifi); const { personaId, identifierId, wasCreated, } = await personaService.createUpdateIdentifierPersona({ organisation: statement.organisation, ifi, personaName, }); let display = 'Unknown name'; try { const { persona } = await personaService.getPersona({ organisation: statement.organisation, personaId }); if (persona) { display = persona.name; } } catch (err) { logger.error('Error finding person - not updating statement', err); } if (!wasCreated) { statement.personaIdentifier = identifierId; statement.person = { _id: personaId, display, }; await statement.save(); } else { await asignIdentifierToStatements({ organisation: statement.organisation.toString(), toIdentifierId: identifierId }); } };
this.getAccessTokenAsync(user, (err, token) => { if (err) { logger.error("Error while creating token for rollNo: " + user.rollNo, err) res.status(500) .json({ success: false, error: { code: "SERVER_ERROR" }}) } else { // Save `token` to database. AccessToken.create({ token: token, ttl: config.jwtTTL, rollNo: user.rollNo }).then(token => { res.status(200) .json({ success: true, token: token.token }) }).catch(err => { logger.error("Error while saving token to database for rollNo: " + user.rollNo, err) res.status(500) .json({ success: false, error: { code: "SERVER_ERROR" }}) }) } })
const defaultHandleResponse = (err) => { if (err) logger.error(`ERROR SUBSCRIBING TO QUEUE ${EMAIL_EXPIRATION_NOTIFICATION_QUEUE}`, err); return err; };
assert.doesNotThrow(function () { logger.error('Error Firefox!'); });
define(function (require, exports, module) { 'use strict'; const AuthErrors = require('lib/auth-errors'); const domWriter = require('lib/dom-writer'); const FiveHundredTemplate = require('stache!templates/500'); const FourHundredTemplate = require('stache!templates/400'); const Logger = require('lib/logger'); const OAuthErrors = require('lib/oauth-errors'); const p = require('lib/promise'); module.exports = { /** * Get the URL of the error page to which an error should redirect. * * @param {Error} error - error for which to get error page URL * @returns {String} */ getErrorPageTemplate (error) { if (AuthErrors.is(error, 'INVALID_PARAMETER') || AuthErrors.is(error, 'MISSING_PARAMETER') || OAuthErrors.is(error, 'INVALID_PARAMETER') || OAuthErrors.is(error, 'MISSING_PARAMETER') || OAuthErrors.is(error, 'UNKNOWN_CLIENT')) { return FourHundredTemplate; } return FiveHundredTemplate; }, /** * Report an error to metrics. No metrics report is sent. * * @param {Error} error * @param {Object} sentryMetrics * @param {Object} metrics * @param {Object} win */ captureError (error, sentryMetrics, metrics, win) { var logger = new Logger(win); logger.error(error); // Ensure the message is interpolated before sending to // sentry and metrics. try { // some errors do not allow reassigning a read-only message property error.message = this.getErrorMessage(error); } catch (e) { // unable to change error message. } sentryMetrics.captureException(error); if (metrics) { metrics.logError(error); } }, /** * Report an error to metrics. Send metrics report. * * @param {Error} error * @param {Object} sentryMetrics * @param {Object} metrics * @param {Object} win * @returns {Promise}; */ captureAndFlushError (error, sentryMetrics, metrics, win) { this.captureError(error, sentryMetrics, metrics, win); return p().then(function () { if (metrics) { return metrics.flush(); } }); }, /** * Render an error to the DOM * * @param {Error} error * @param {Object} win * @param {Object} translator */ renderError (error, win, translator) { var errorPageTemplate = this.getErrorPageTemplate(error); var errorMessage = this.getErrorMessage(error, translator); var errorHtml = errorPageTemplate({ message: errorMessage, t: getTranslationHelper(translator) }); domWriter.write(win, errorHtml); }, /** * Handle a fatal error. Logs and reports the error, then redirects * to the appropriate error page. * * @param {Error} error * @param {Object} sentryMetrics * @param {Object} metrics * @param {Object} win * @param {Object} translator * @returns {Promise} */ fatalError (error, sentryMetrics, metrics, win, translator) { return p.all([ this.captureAndFlushError(error, sentryMetrics, metrics, win), this.renderError(error, win, translator) ]); }, /** * Get the error message, performing any interpolation. If a translator * is passed, return value will be translated to the user's locale. * * @param {String} error - an error object * @param {Object} [translator] - translator to translate error * @return {String} interpolated error text. */ getErrorMessage (error, translator) { if (error && error.errorModule) { return error.errorModule.toInterpolatedMessage(error, translator); } return error.message; } }; function getTranslationHelper(translator) { // Use the translator's helper if available, if the translator // is not available (the app could error before the translator is // created), then create a standin. if (translator) { return translator.translateInTemplate.bind(translator); } // create the standin helper. return function () { return function (msg) { return msg; }; }; } });
}).catch(err => { logger.error(err) res.status(500) .json({ success: false, error: { code: "SERVER_ERROR" }}) })
}).catch(err => { logger.error("Error while saving token to database for rollNo: " + user.rollNo, err) res.status(500) .json({ success: false, error: { code: "SERVER_ERROR" }}) })
.catch((err) => { logger.error(err); });
define(function (require, exports, module) { 'use strict'; const _ = require('underscore'); const Errors = require('lib/errors'); const Logger = require('lib/logger'); var logger = new Logger(); const Strings = require('lib/strings'); var t = function (msg) { return msg; }; var UNEXPECTED_ERROR = t('Unexpected error'); /*eslint-disable sorting/sort-object-props*/ var ERRORS = { UNKNOWN_CLIENT: { errno: 101, message: t('Unknown client') }, INCORRECT_REDIRECT: { errno: 103, message: t('Incorrect redirect_uri') }, INVALID_ASSERTION: { errno: 104, message: t('Invalid assertion') }, UNKNOWN_CODE: { errno: 105, message: t('Unknown code') }, INCORRECT_CODE: { errno: 106, message: t('Incorrect code') }, EXPIRED_CODE: { errno: 107, message: t('Expired code') }, INVALID_TOKEN: { errno: 108, message: t('Invalid token') }, INVALID_PARAMETER: { errno: 109, message: t('Invalid OAuth parameter: %(param)s') }, INVALID_RESPONSE_TYPE: { errno: 110, message: UNEXPECTED_ERROR }, UNAUTHORIZED: { errno: 111, message: t('Unauthorized') }, FORBIDDEN: { errno: 112, message: t('Forbidden') }, INVALID_CONTENT_TYPE: { errno: 113, message: UNEXPECTED_ERROR }, INVALID_SCOPES: { errno: 114, message: Strings.interpolate( // `scope` should not be translated, so interpolate it in. t('Invalid OAuth parameter: %(param)s'), { param: 'scope' }) }, SERVICE_UNAVAILABLE: { errno: 998, message: t('System unavailable, try again soon') }, UNEXPECTED_ERROR: { errno: 999, message: UNEXPECTED_ERROR }, TRY_AGAIN: { errno: 1000, message: t('Something went wrong. Please close this tab and try again.') }, INVALID_RESULT: { errno: 1001, message: UNEXPECTED_ERROR }, INVALID_RESULT_REDIRECT: { errno: 1002, message: UNEXPECTED_ERROR }, INVALID_RESULT_CODE: { errno: 1003, message: UNEXPECTED_ERROR }, USER_CANCELED_OAUTH_LOGIN: { errno: 1004, message: t('no message') }, MISSING_PARAMETER: { errno: 1005, message: t('Missing OAuth parameter: %(param)s') } }; /*eslint-enable sorting/sort-object-props*/ module.exports = _.extend({}, Errors, { ERRORS: ERRORS, NAMESPACE: 'oauth', /** * Fetch the interpolation context out of the server error. * @param {Error} err * @returns {Object} */ toInterpolationContext (err) { // For data returned by backend, see // https://github.com/mozilla/fxa-oauth-server/blob/master/docs/api.md#errors try { if (this.is(err, 'MISSING_PARAMETER')) { return { param: err.param }; } else if (this.is(err, 'INVALID_PARAMETER')) { return { param: err.param || err.validation.keys.join(',') }; } } catch (e) { // handle invalid/unexpected data from the backend. logger.error('Error in oauth-errors.js->toInterpolationContext: %s', String(e)); } return {}; } }); });
const defaultHandleResponse = (err) => { if (err) logger.error(`ERROR SUBSCRIBING TO QUEUE ${BATCH_STATEMENT_DELETION_QUEUE}`, err); return err; };
addStatementToPendingQueues(statement, queueDependencies, (err) => { if (err) logger.error('addStatementToPendingQueues error', err); if (jobDone) return jobDone(err); });
statementStream.on('error', (err) => { logger.error(err); process.exit(); });
app.use((err, req, res, next) => { logger.error(err) res.status(500) .send({ success: false, error: { code: "SERVER_ERROR" }}) })
cacheStream.on('error', (err) => { logger.error(err); process.exit(); });
const statementForwardingRequestHandler = async ( { statement, statementForwarding }, done, { queue = Queue } = {} ) => { try { await setPendingStatements( statement, statementForwarding._id ); await sendRequest( statementForwarding.fullDocument ? statement : statement.statement, statementForwarding, statement ); await setCompleteStatements(statement, statementForwarding._id); logger.debug( `SUCCESS sending statement ${statement._id} to ${statementForwarding.configuration.url}` ); done(); } catch (err) { logger.info( `FAILED sending statement ${statement._id} to ${statementForwarding.configuration.url}`, err ); let update = { timestamp: new Date(), statementForwarding_id: objectId(statementForwarding._id), message: err.toString() }; if (err.messageBody) { if (isPlainObject(err.messageBody)) { update = assign({}, update, { errorInfo: err.messageBody }); } } try { await Statement.updateOne( { _id: statement._id }, { $addToSet: { failedForwardingLog: update } } ); const updatedStatement = await Statement.findOne({ _id: statement._id }); if ( updatedStatement.failedForwardingLog.length <= statementForwarding.configuration.maxRetries ) { logger.info(`SENDING statement ${updatedStatement._id} to ${STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE}`); queue.publish({ queueName: STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE, payload: { status: STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE, statement: updatedStatement, statementForwarding } }, (err) => { if (err) { logger.error(`FAILED sending statement ${updatedStatement._id} to ${STATEMENT_FORWARDING_REQUEST_DELAYED_QUEUE}`, err); done(err); throw new Error('Error publishing to queue'); } done(); return; }); } else { logger.info(`EXCEEDED max retry for statement ${updatedStatement._id}, failing (should go to dead letter queue).`); done(err); // failed, let redrive send to dead letter queue } } catch (err) { logger.error('Failed updating failedForwardingLog', err); } } return [statement._id]; };
const logError = err => logger.error(err);
const promise = handleJob(statements).catch((err) => { logger.error(err); return err; });