Background Real-Time Heartbeat (knock-off background daemon threads)

Mimic having a background daemon to run jobs as needed along with the ability to pause, restart, add and remove jobs. (Almost like a real-time live only cron service). This is just a fun little thing I built to see how it would perform and am curious if it may potentially be useful in the future.

So, whats the point of this?

Simple, mimic having a background daemon to run jobs as needed along with the ability to pause, restart, add and remove jobs. (Almost like a real-time live only cron service)

The Heartbeat

So I want to be able to add and remove async functions to this. (maybe have it use something like redis in the future too) but overall just some simple background tasks that can run on a tick (like a video game or something) and customize when it runs, how many times it runs and can track metadata about itself on each run (maybe even persist to a db if needed).

I also want to have it intake just functions with a key or a full on object with it's own state with a key. This is a really fun thing to build BTW.

The Code

Here's the fun part, based on what is above, I put in some logic (I know the code isn't perfect but it works, bare with me a moment).

export class HeartBeat {
  #registered = {};
  #intervalDelta = 5000;

  constructor({ intervalDelta }) {
    this.intervalId = 0;
    this.#intervalDelta = intervalDelta ? intervalDelta : 5000;
    this.running = false;
    this.tick = 0;
  }

  start() {
    this.running = true;
    this.intervalId = setInterval(async () => {
      if (this.running) {
        this.tick++;
        let keys = Object.keys(this.#registered);
        for (let i = 0; i < keys.length; i++) {
          try {
            if (typeof this.#registered[keys[i]] === 'function') {
              await this.#registered[keys[i]]();
              continue;
            }
            if (typeof this.#registered[keys[i]] === 'object') {
              if (Object.keys(this.#registered[keys[i]]).join('') === Object.keys(new HeartBeatItem({})).join('')) {
                this.#registered[keys[i]].run(this.tick);
              }
            }
          } catch (error) {
            console.log(`Failed execution on '${keys[i]}' ::`, { error })
          }
        }
      }
    }, this.#intervalDelta);

    console.log("HeartBeat Started...")
  }

  stop() {
    this.running = false;
    clearInterval(this.intervalId);
    console.log("HeartBeat Stopped...")
  }

  changeInterval(delta) {
    if (delta && typeof delta === 'number') {
      this.running = false;
      clearInterval(this.intervalId);
      this.#intervalDelta = delta;
      this.start();
    }
  }

  exists(key) {
    return key in this.#registered;
  }

  register(key, func) {
    if (!this.exists(key)) {
      this.#registered[key] = func;
    }
  }

  currentTick() {
    return this.tick;
  }

  keys() {
    return Object.keys(this.#registered);
  }

  remove(key) {
    if (this.exists(key)) {
      delete this.#registered[key];
    }
  }
}

The `HeartBeatItem` for metadata tracking

So as mentioned before, I want to pass anonymous functions as well as full on objects that track state, enter the HeartBeatItem. This is actually declared above the HeartBeat class and is used in validation of added objects to ensure compatibility.

export class HeartBeatItem {
  constructor({ func, modTick, startPaused, maxRuns, metadata }) {
    this.func = func || null;
    this.modTick = modTick || 0;
    this.timesRan = 0;
    this.maxRuns = maxRuns || 0;
    this.paused = startPaused || false;
    this.metadata = metadata || {};
    this.lastTickRan = 0;
  }

  run(tick) {
    if (this.paused) {
      return;
    }

    let runFunc = true;

    if (this.maxRuns) {
      runFunc = this.timesRan + 1 < this.maxRuns;
    }

    if (this.modTick) {
      runFunc = (tick % this.modTick) === 0;
    }

    if (runFunc) {
      (async () => {
        this.timesRan++;
        this.lastTickRan = tick;
        await this.func(this);
      })()
    }
  }

  pause() {
    this.paused = true;
  }

  unPause() {
    this.paused = false;
  }
}

You are able to change these items throughout your app and also pause,unpause them. Change how often they run, etc... They idea is to have sort of dynamic changes added into your page or server without needing some heavy framework, just some simple code to have tasks open at regular intervals and control the flow of them.

Implementation

So you, in theory, could pass anything you want to run to this. DB updates, fetching API stuffs, polling, etc... I'm going to do some more testing on this because I find this really fun and intriguing but here is a basic implementation for this.

import { HeartBeat, HeartBeatItem } from "./index.js";

export const heartbeat = new HeartBeat({ intervalDelta: 500 });
heartbeat.start();

heartbeat.register("Hello World!", () => { console.log("Hello World!") })

let item = new HeartBeatItem({
  func: async (context) => {
    let delta = (new Date() - new Date(context.metadata.inception)) / 1000;

    context.metadata[`Iter ${context.timesRan}`] = `${delta}s since starting`

    console.log({ context });

    if (!context.modTick) {
      context.modTick = 1;
    } else {
      context.modTick *= 2;
    }
  },
  metadata: {
    inception: new Date(),
  }
})

heartbeat.register("RealHeartBeatItem", item);

As you can see, if the passed item is a heartbeat item, it passes the object back into the function in order to check different things within the object, in addition, it adds the current tick and delta into it for doing calculations and other various things.

Results from running the above code.

HeartBeat Started...
Hello World!
{
  context: HeartBeatItem {
    func: [AsyncFunction: func],
    modTick: 0,
    timesRan: 1,
    maxRuns: 0,
    paused: false,
    metadata: {
      inception: 2024-12-23T17:50:38.750Z,
      'Iter 1': '0.497s since starting'
    },
    lastTickRan: 1
  }
}
Hello World!
{
  context: HeartBeatItem {
    func: [AsyncFunction: func],
    modTick: 1,
    timesRan: 2,
    maxRuns: 0,
    paused: false,
    metadata: {
      inception: 2024-12-23T17:50:38.750Z,
      'Iter 1': '0.497s since starting',
      'Iter 2': '1s since starting'
    },
    lastTickRan: 2
  }
}
Hello World!
Hello World!
{
  context: HeartBeatItem {
    func: [AsyncFunction: func],
    modTick: 2,
    timesRan: 3,
    maxRuns: 0,
    paused: false,
    metadata: {
      inception: 2024-12-23T17:50:38.750Z,
      'Iter 1': '0.497s since starting',
      'Iter 2': '1s since starting',
      'Iter 3': '2.004s since starting'
    },
    lastTickRan: 4
  }
}
Hello World!
Hello World!
Hello World!
Hello World!
{
  context: HeartBeatItem {
    func: [AsyncFunction: func],
    modTick: 4,
    timesRan: 4,
    maxRuns: 0,
    paused: false,
    metadata: {
      inception: 2024-12-23T17:50:38.750Z,
      'Iter 1': '0.497s since starting',
      'Iter 2': '1s since starting',
      'Iter 3': '2.004s since starting',
      'Iter 4': '4.017s since starting'
    },
    lastTickRan: 8
  }
}
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
{
  context: HeartBeatItem {
    func: [AsyncFunction: func],
    modTick: 8,
    timesRan: 5,
    maxRuns: 0,
    paused: false,
    metadata: {
      inception: 2024-12-23T17:50:38.750Z,
      'Iter 1': '0.497s since starting',
      'Iter 2': '1s since starting',
      'Iter 3': '2.004s since starting',
      'Iter 4': '4.017s since starting',
      'Iter 5': '8.037s since starting'
    },
    lastTickRan: 16
  }
}
...

As you can see here, this is really cooooooll!! At least, I think it is. I played around with this idea for while and I think I can go somewhere with it. Not sure 100% yet.

What do you think? Is this cool? I want to spend more time on it, just been busy with other work

Don't forget to have fun learning and building things! -jdev

<<< Previous Post