Love this package BTW, been using it for a long time for my job processing however I'm now in need of a priority/hierarchy of jobs.

For example I want a certain job type to always execute immediately, before other job types - even if there's a backlog of jobs of other types.

Is this possible at all? I saw in another answer you wrote something about if you change sleepUntil to another value you can have different queues - not sure if this could be applied somehow?

Thanks!

Couple of questions, all related to restarting instances:

The documentation says:

If cron is unexpectedly interrupted during the processing of a job (e.g. server shutdown), the system automatically recovers and transparently restarts.

• Does this mean, when my app has a bunch of jobs defined and uses collection.create() every time it starts, it will not re-create those jobs, if they already exist?
• How does mongodb-cron identify that the job I'm trying to create already exists? There doesn't seem to be an identifier I can set.
• What about multiple instances, say if I have several replicas of my app running (e.g. in k8s or docker swarm)? Can mongodb-cron handle this seamlessly, when all the replicas are trying to access the job queue collection and process jobs at the same time?

Many thanks.

When I activate the cron in the application, the CPU usage on this process is actively showing between 20% - 25%. If I disable the cron, then the usage drop to 0.
The application is running in a test environment, and no other activities happens.

Is this the expected behaviour?
I am using pm2 (v3.5.1) to monit the cpu usage. ($ top -c shows the same CPU usage report)

Btw, thanks for your great work!

When I add the idleDelay flag in the configuration and start the application, the worker does not process any queued jobs, even it has passed the defined sleepUntil time.

If the idleDelay flag is removed from configuration, the job is being processed correctly, however, it consume about 12% - 15% CPU usage when cron activated.

I set all queued one-time job to be processed at 5pm everyday, and I wish the cron to be active at approximately 5 mins before job start, so this will reduce my CPU usage over the day time.

Code snippet

// mongoose schema
const schema = new mongoose.Schema({
    ... ...
    sleepUntil: {type: Date, required: true, index: true, default: (5pm every day)},
    autoRemove: {type: Boolean, default: true} 

}, {collection: 'Queue'});


// cron setting
const config = {
    collection: db.collection('Queue'),
    onDocument: (async (doc) => { return console.info(doc); }),
    onStart: (async () => { return console.info('cron started.'); }),
    onStop: (async () => { return console.warn('cron has stopped.'); }),
    idleDelay: 60 * 1000  // 1 min delay
};
return new MongoCron(config);

or are there any sqlite3 crontab module to create cronjobs？

The sleepUntil property is required when defining cron jobs but never documented. I think it shouldn't be required to specifically declare it null if possible, if not then docs should be added.

In mongo version 6, they have made breaking changes to findOneAndUpdate (https://github.com/mongodb/node-mongodb-native/blob/main/etc/notes/CHANGES_6.0.0.md#findoneandx-family-of-methods-will-now-return-only-the-found-document-or-null-by-default-includeresultmetadata-is-false-by-default).

Now, it simply returns the document without any metadata, so in the following res.value will be undefined, it simply needs to return res.

Also, returnOriginal has been removed and should be replaced with returnDocument: 'before'

  protected async lockNext() {
    const sleepUntil = moment().add(this.config.lockDuration, 'milliseconds').toDate();
    const currentDate = moment().toDate();

    const res = await this.getCollection().findOneAndUpdate({
      $and: [
        { [this.config.sleepUntilFieldPath]: { $exists: true, $ne: null }},
        { [this.config.sleepUntilFieldPath]: { $not: { $gt: currentDate } } },
        this.config.condition,
      ].filter((c) => !!c),
    }, {
      $set: { [this.config.sleepUntilFieldPath]: sleepUntil },
    }, {
      returnOriginal: true, // return original document to calculate next start based on the original value
    });
    return res.value;
  }

If you could please update this so we can upgrade to mongo 6 that would be appreciated! Thanks.

This plugin has some vulnerability issues. Need to fix it.

https://snyk.io/test/npm/mongodb-cron/1.7.0

Hello,

We want to use mongodb-cron for our project within Azure and the managed database Cosmos via the MongoAPI.

For that we have to use the condition as Cosmos requires always the partition key in a query/update/delete operation.

Unfortunately the condition is only use in the lockNext() but not in the final update/delete in reschedule.

I would like to add the this.config.condition to all query statements regardless of find/delete/update/...

Does some see problems with that?

I have a single job entry in the database, when the server time reach the sleepUnitl time, the job is being executed twice inside the onDocument method.

Here are my settings:

MongoDB Schema

const schema = new Schema(
    {
      name: { type: String, required: true },
      sleepUntil: { type: Date, default: new Date(), required: true },
      interval: { type: String, required: true },
      data: { type: Schema.Types.Mixed }
    },
    {
      timestamps: true
    }
  );

MondoDB Entry

{
    "_id": ObjectId("65d37bbf7933cf20f1064ee3"),
    "name": "JOB_TO_RUN",
    "interval": "0 0 6 * * *",
    "sleepUntil": ISODate("2024-03-19T09:00:00.000Z"),
    "data": {},
    "updatedAt": ISODate("2024-03-01T15:15:14.647Z")
}

Cron job execution code

const { MongoCron } = require('mongodb-cron');

module.exports = async app => {
  const mongooseClient = app.get('mongooseClient');
  const collection = await mongooseClient.connections[0].collections['cron-jobs'];

  const cron = new MongoCron({
    collection,
    onStart: () => console.info('\t✓ Cron jobs.'),
    onDocument: doc => console.count(), // You will get a 2 console logs here!
    onError: async err => console.error(err),
    nextDelay: 1000,
    reprocessDelay: 1000,
    idleDelay: 1000
  });

  cron.start();
};

Hi @xpepermint ,

As far as I can observe the library always works with UTC timestamps in the sleepUntil and interval field.
Is it possible to configure the library at the current state to react to summer time changes?

If not here is my idea:
I can see that the library uses moment.
In my code I use moment with the timezone extension. (moment-timezone)
I suppose with changing the imports from import moment from 'moment'; to import moment from 'moment-timezone'; and adding a default timezone moment.tz.setDefault('Europe/Zurich'); the behaviour could be altered.
Of course this would need a new option in the constructor. e.g. new MongoCron({..., timezon: 'Europe/Zurich'})

I didn't test it and have not looked deep into the code.
What do you think?

Thanks,
Daniel

This may be something that's just supported inherently by cron but before I start using this would like to know how its handled with this library:

If I schedule a job to run every week to create a new document but my server is down during that time period, does it run the next time the system is started? Does this keep track of when the next run time should be and on bootup check if theres any jobs past their next run time? Or do I need to handle that logic separately?