Strange behavior with Mongoose

[lopezjurip]

Trying mongoose with context.callbackWaitsForEmptyEventLoop = false so the function should end after calling callback(...) works different while using serverless-webpack as a plugin and when manually packing the project with webpack.

// webpack.config.js
module.exports = {
  entry: './handler.js',
  target: 'node',
  output: {
    libraryTarget: 'commonjs',
    path: 'dist',
    filename: 'handler.js',
  },

  // Any module with native extensions has to be excluded
  externals: [
    'mongoose',
  ],
}

// handler.js
'use strict';
import mongoose from 'mongoose';
import Promise from 'bluebird';

export const UserSchema = new mongoose.Schema({
  name: String,
});
const User = mongoose.model('User', UserSchema);

const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost/lambda';
mongoose.connect(MONGO_URI);

module.exports.handler = (event, context, callback) => {
  context.callbackWaitsForEmptyEventLoop = false
  return User.find({})
    .then(results => callback(null, results))
    .catch(callback);
};

With serverless-webpack

# serverless.yml
service: users

plugins:
  - serverless-webpack

custom:
  webpackIncludeModules: true

functions:
  index:
    handler: handler.handler
    events:
      - http:
          path: users
          method: get

When calling the function it gets stuck on some event-loop and eventually it times-out on AWS.

Without serverless-webpack

# serverless.yml
service: users

package:
  include:
    - dist/**

functions:
  index:
    handler: dist/handler.handler
    events:
      - http:
          path: users
          method: get

Manually running webpack and:

cd dist 
echo "{}" > package.json 
npm i --save mongoose
cd ..

And then running it locally or on production it work as expected.

[hassankhan]

This is more likely to do with connection pooling than with this package. Check Mongoose's docs for how to drain/close the pool, there usually is a way. Does it work without Webpack in production?

[diit]

Had a very similar issue that drove me insane, was fixed it for me was to close the Mongo db connection.
mongoose.disconnect()

[lopezjurip]

Note context.callbackWaitsForEmptyEventLoop = false, when disabled it finish even if the connection is live. The problem that is the same code works different with and without webpack.

[pixeldrew]

I would use the native Promise on 6.10 as there are other threads with a similar issue.

[ed-zm]

Any solution for this?

[HyperBrain]

If you set context.callbackWaitsForEmptyEventLoop = false and use the callback you must not return anything from the handler. In your case the .then() will execute the callback correctly BUT it will also return a promise (even if the promise is resolved to undefined).

That might lead to races in AWS' Lambda code (does the callback get fired first, or does the returned promise resolve first?). AWS Lambda supports returning promises from handlers instead of using the callbacks since a while.

A safe and correct implementation would be:

module.exports.handler = (event, context, callback) => {
  context.callbackWaitsForEmptyEventLoop = false;
  User.find({})
    .then(results => callback(null, results))
    .catch(callback);
  return;   // The callback is used so nothing must be returned
};

It might be that using the plugin or using webpack externally creates slightly different code with different timing behavior.

[HyperBrain]

@mrpatiwi Is this issue still valid? In the meantime 3.0.0-rc.2 is already available. If you don't mind you can try it.

[HyperBrain]

Closing the issue as there has been no feedback. Feel free to reopen it or create a new one for the most current version if the issue still persists.

[edjroz]

@HyperBrain I'm also having this issue. Has anyone found any solution ?

handler.js

import 'babel-polyfill';

import { createInsertDocHandler } from './handlers';
import createRepository from './repositories/mongodb';

const db = createRepository(process.env.DB_URL);

exports.insertDoc = createInsertDocHandler(db);

handlers/index.js

import debug from 'debug';
import dummyModel from '../util/models/dummy';
import responseWrapper from '../util/responseWrapper';


const mapBodyResponse = ({ _id, name }) => ({ _id, name });

export const createInsertDocHandler = db => async (event, context, callback) => {
  debug('function:req:params')(event.pathParameters);
  debug('function:req:body')(JSON.parse(event.body));

  context.callbackWaitsForEmptyEventLoop = false;

  const document = await db
    .insert(dummyModel, query)
    .then(doc => doc)
    .catch(e => callback);
  debug('function:res')(document);
 
 return callback(null, document);
}

repositories/mongodb.js

import mongoose from 'mongoose';

const createRepository = url => {
  mongoose.connect(url).connect;
  return {
    insert: async (model, query) => model.create(query),
  };
};

export default createRepository;

I have debugged the deployed version of this function and the insertion operation is being carried away however I'm receiving a 500

whilst performing with rerverless-offline I get this warning
Warning: handler 'insertDocument' returned a promise and also use a callback! This is problematic and might cause issues in you lambda.