Temporos is a Node.js package for scheduling tasks to run at specified intervals. It offers features such as customizable logging, advanced scheduling options, dynamic concurrency control, task dependencies, and batch task scheduling.

To install Temporos, use npm:

npm install temporos

To use Temporos, first import it into your project:

const temporos = require('temporos');

To schedule a task, call the scheduleTask() function and pass it a callback function and an interval in milliseconds:

const taskId = temporos.scheduleTask(myCallback, 60000); // Run myCallback every minute

Temporos provides a default logging function that logs to the console, but users can also provide their own custom logging function. To do this, simply pass a logger function as an option when scheduling a task:

function customLogger(msg) {
  // Implement custom logging here
}

temporos.scheduleTask(myTask, 5000, { logger: customLogger });

By default, tasks are scheduled to run at a fixed interval. However, Temporos also provides options for more advanced scheduling, such as running tasks on specific days of the week or at specific times of day. Note: If using null as the interval, Temporos will calculate the next run time based on the advanced options provided.

function myTask() {
  console.log('Running task...');
}

temporos.scheduleTask(myTask, null, {
  weekdays: [1, 3, 5],  // Run on Mondays, Wednesdays, and Fridays
  timesOfDay: ['09:00', '13:00', '17:00']  // Run at 9am, 1pm, and 5pm
});

Sometimes it's necessary to run one task only after another has completed. Temporos provides a mechanism for specifying task dependencies. When scheduling a task, simply provide an array of task IDs that the new task depends on:

function taskA() {
  console.log('Running task A...');
}

function taskB() {
  console.log('Running task B...');
}

const taskIdA = temporos.scheduleTask(taskA, 5000);
const taskIdB = temporos.scheduleTask(taskB, 5000, { dependencies: [taskIdA] });
// Task B will not run until task A has completed.

Temporos allows you to set a maximum concurrency level for running tasks, and will automatically adjust the concurrency level based on system resource usage. To start the concurrency monitor, use the startConcurrencyMonitor method:

temporos.startConcurrencyMonitor();

To set the maximum concurrency level, use the setMaxConcurrency method:

temporos.setMaxConcurrency(4);

Temporos allows you to schedule tasks in batches. To enable batch task scheduling, simply set the batch option to true when scheduling a task:

const taskId = temporos.scheduleTask(myCallback, 60000, { batch: true });

Temporos allows you to prioritize certain tasks by adding them to a priority queue:

const taskId = temporos.scheduleTask(myCallback, 60000);
temporos.prioritizeTask(taskId, 10); // Higher number indicates higher priority

This implementation uses the cluster module in Node.js to fork multiple worker processes that run the same code. Each worker process checks for tasks to run every second, allowing tasks to be executed concurrently across multiple CPU cores.

const ClusterScheduler = require('temporos').ClusterScheduler;
const scheduler = new ClusterScheduler();

Temporos can be easily integrated with external systems by scheduling tasks based on events or data from those systems. The specific details of the integration will depend on the external system being used, but Temporos provides a flexible API that can be adapted to a wide range of use cases.

Temporos offers the following methods:

• scheduleTask(callback: function, interval: number, options?: object): symbol - Schedules a task to run at the specified interval. Returns a unique task ID.
• cancelTask(taskId: symbol): void - Cancels a scheduled task.
• startConcurrencyMonitor(interval?: number): void - Starts the concurrency monitor, which adjusts the maximum concurrency level based on system resource usage. The interval parameter specifies how often to check system resource usage (default is 1000ms).
• stopConcurrencyMonitor(): void - Stops the concurrency monitor.
• setMaxConcurrency(max: number): void - Sets the maximum concurrency level for running tasks.
• getRunningTasks(): symbol[] - Returns an array of task IDs for tasks that are currently running.
• prioritizeTask(taskId: symbol, priority: number): void - Adds a task to the priority queue.

Contributions to Temporos are welcome! To contribute, please fork the repository and submit a pull request.

Temporos is licensed under the MIT license. See the LICENSE file for details.