node package manager



Scalable time-based counters that meant logging, graphing and providing a realtime statistics. All features in tempo are meant to have a constant size memory footprint defined by configuration.

For a quick example, please look at examples/simple-use-case.js


  1. simple counters that sync over redis using a hash structure
  2. counters that keep track of historical data in buckets
  3. syncing with redis for aggregation on multiple servers
  4. throttling

Use Case

Lets say you are running a website and want to know in realtime where people are visiting.

  var redis = require('redis').createClient();
  var tempo = require('tempo');
  // create middleware to track counts 
  // create time counter, increment and sync 
  var min = tempo.min();
  app.use(function (req, res, next) {
    // the '1' is unnecessary because increment defaults to '1''requests', 1); 
    if (min.getCount('requests') > 1000) return next('throttled');
  function showTotalRequestsInPastMin() {
    min.getKeys().forEach(function (k) { console.log(k, min.getCount(k)) });
  function showRequestsOverTime() {
    min.eachCount('requests', function (count, time) {
      console.log("Requsts at " + (new Date(time)).toString() + '' + count); 
    console.log(tempo.getCount('requests') + ' request(s) made in the last minute'); 


The tempo TimedCounter class allows you to create a datastore object and keep data in memory.

Instance methods

var counter = new tempo.Counter(options)

  1. options hash
  2. per: milliseconds per bucket
  3. buckets: number of buckets
  4. timeout (optional): Time to live. Mainly for redis syncing. Defaults to (perbucket)+per2

Example for keeping data up to an hour of history:

var tempo = require('tempo');
var ds = new tempo.TimedCounter({ per: 60000, buckets: 60 });, [n]); O(1)

  1. key: entity name
  2. n (optional, defaults to 1): a number to increment by.

Keeping track of how many times a user has logged in in the past hour:

  var ds = require('tempo').hour();;

counter.getHistory(key); O(n)

  1. key: entity name

Grabbing logged in counts:

  var history = ds.getHistory(userId);

Returns an array of counts (per bucket)

counter.sync([callback]) O(nb)

  1. redis client
  2. prefix/namespace for the key to store in redis
* tempo's keys will look something like "<namespace>:<timestamp>"
  1. O(nt) where n is the number of keys and b is the number of buckets
  counter.sync(redis, 'web-stats', callback);

counter.getKeys(); O(nb)

returns and array of all the keys in the counter O(nt) where n is the number of keys and b is the number of buckets

counter.eachCount(key1, key2, ... [ callback ])

Runs a callback against every bucket in the counter with arguments (see examples below):

counter.eachCount('key1', 'key2', function (keyCount1, keyCount2, time) {
  console.log('key1', keyCount1, ' at ' + (new Date(time)).toString());
  console.log('key2', keyCount2, ' at ' + (new Date(time)).toString());
# Syncer
var tempo = require('tempo');
var syncer = new tempo.Syncer(redisClient);

Instance methods


Adds a counter to the list of counters to sync at once

var counter = syncer.counter(options)

Shortcut to instantiate counter and add it

syncer.sync([ callback ])

Syncs all counters to redis (push and pull)

syner.push([ callback ])

Pushes data to redis

syncer.pull([ callback ])

Pulls data from redis

syncer.start(type, interval)

Starts running a type of sync at given intervals between syncs

syncer.start('push', 3000) // push to redis every 3 seconds