When installing timesync via npm, the following warning message is displayed:

npm WARN deprecated [email protected]: Debug versions >=3.2.0 <3.2.7 || >=4 <4.3.1 have a low-severity ReDos regression when used in a Node.js environment. It is recommended you upgrade to 3.2.7 or 4.3.1. (https://github.com/visionmedia/debug/issues/797)

It'd be nice if there was a way to just shove a duplex stream from somewhere into this and have it work from that rather than specifying URLs and making assumptions about the transport medium.

Since socket.io is only used in an example and is not required to use timesync in a project, it should not be a dependency.

Hello

Your project is great. It's precisely what I'm looking for... Except for the dependency toward a JSON-RPC API.

My app is based on a GraphQL API, but my understanding is that JSON-RPC is hard-coded.

Maybe I missed something: is there an easy way to override this?

Thanks!

Hi,
it would be great to have typescript types.

Hello there, first off thanks for writing this awesome library, it saved me a lot of time getting my project off the ground!

The only "issue" I've had is with the fixed sample count. I'd like the option of using a more "adaptive" sampling strategy that will e.g. take as many samples as necessary to guarantee with some confidence level (e.g. 98%) that the true offset has been found to within some tolerance (e.g. 10ms). This would be really nice for applications like mine where you need some guarantees on the level of synchronization.

As currently implemented, we can only control the total number of samples taken. But for clients with very low variance in offset measurements, the sample count could be overkill, and for clients with very high variance in offset measurements, the sample count could be too low.

I ultimately ended up implementing this sampling strategy myself for my project; here is the code:

class SamplePolicy {
    shouldSample(samples) {
        throw new Error('Not implemented');
    }
}


/** Take maxSamples (current timesync behavior). */
class MaxSamplesPolicy extends SamplePolicy {
    constructor(maxSamples) {
        super();
        this.maxSamples = maxSamples;
    }

    shouldSample(samples) {
        return samples.length < this.maxSamples;
    }
}


/**
 * Keep sampling until the offset is known to within the margin of error (MoE)
 * with the given confidence level.
 */
class AutoSamplePolicy extends SamplePolicy {
    constructor(config) {
        super();

        this.minSamples = config.minSamples;
        this.maxSamples = config.maxSamples;
        this._z = CI_TO_Z[config.confidenceLevel];
        this.moe = config.moe;
    }

    shouldSample(samples) {
        if (samples.length < this.minSamples) {
            return true;
        } else if (samples.length >= this.maxSamples) {
            return false;
        }

        const stddev_ = stddev(samples);
        const n = Math.ceil(Math.pow(this._z * stddev_ / this.moe, 2));

        return samples.length < n;
    }
}


/** Confidence interval to Z-score. */
const CI_TO_Z = {
    0.80 : 1.281551565545,
    0.85 : 1.439755747982,
    0.90 : 1.644853626951,
    0.95 : 1.959963984540,
    0.98 : 2.326347874041,
    0.99 : 2.575829303549,
    0.995: 2.807033485986,
    0.998: 3.090232306168,
    0.999: 3.290526731492,
};

I have used this module in a realtime web game. The websocket module I use is uws. But sometimes I get the error saying it couldn't perform send function on null and located to this line of my code. But this doesn't happen all the time. It only happens occasionally so it is hard to reproduce. What could possibly be the reason?

      ts.send = function(socket, data) {
      	socket.send(JSON.stringify(data));
  };

The above code is similar to socket.io example in your code but I am actually using a native browser websocket implementation.

I wanted to give a uws/ws implementation example to your code but I don't have much free time at the moment.

Hello,

I was making some tests with this great time sync, but when I put the:

ts.on('error', function (err) {
console.log('error on sync')
}

I turn off the server but the event is not called.

I can see in the console the following message:
timesync.js:962 POST http://localhost:3000/timesync net::ERR_CONNECTION_REFUSED

But no call to the event

From my reading in the source code, it looks like the function to emit the error:

  function emitError(err) {
    if (timesync.list('error').length > 0) {
      timesync.emit('error', err);
    }
    else {
      console.log('Error', err);
    }
  }

is reading from this timesync.list that is not being populated by the event listen subscription, so it is always 0.

If I use the ts.on('change', function()...), it works and shows the change events.

Can anyone check this?

Thanks

When I tried to add timesync.js as a JS script to my .html file, the following warnings appear in the browser console and it doesn't work.

Uncaught SyntaxError: Cannot use import statement outside a module at timesync.js: 9
Uncaught ReferenceError: timesync is not defined at client.html:21

client.html is as follows. Note that unnecessary code is omitted for brevity.

<!DOCTYPE html>
<html>
  <head>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.0.5/es5-shim.min.js"></script> 
    <script src="https://cdnjs.cloudflare.com/ajax/libs/es6-shim/0.23.0/es6-shim.min.js"></script> 
    <script src="./timesync.js"></script>
  </head>
  <body>
    <script>
      // create a timesync instance
      var ts = timesync.create({
        server: "http://localhost:8080/timesync",
        interval: 1000
      }); 
      var socket = io("http://localhost:8080");
    </script>
  </body>
</html>

Wondering if we could get the ability to import using es6 modules.

Hi,

I'm trying to use timesync client in nodejs, but I get an error back when requiring the js file:

var timesync = require('./node_modules/timesync/dist/timesync.js');

this is the error
Error: Cannot find module '_process' at Function.Module._resolveFilename (module.js:325:15) at Function.Module._load (module.js:276:25) at Module.require (module.js:353:17) at require (internal/module.js:12:17) at s (/Users/martijnmellema/Documents/Development/Projecten/groenewijkstroom/wijk-client/node_modules/timesync/dist/timesync.js:1:502) at /Users/martijnmellema/Documents/Development/Projecten/groenewijkstroom/wijk-client/node_modules/timesync/dist/timesync.js:1:647 at Object.14._process (/Users/martijnmellema/Documents/Development/Projecten/groenewijkstroom/wijk-client/node_modules/timesync/dist/timesync.js:1061:14) at s (/Users/martijnmellema/Documents/Development/Projecten/groenewijkstroom/wijk-client/node_modules/timesync/dist/timesync.js:1:596) at /Users/martijnmellema/Documents/Development/Projecten/groenewijkstroom/wijk-client/node_modules/timesync/dist/timesync.js:1:647 at Object.10.asap (/Users/martijnmellema/Documents/Development/Projecten/groenewijkstroom/wijk-client/node_modules/timesync/dist/timesync.js:651:12)

Tried adding the shim files, but still no result:

require('es6-shim');
require('es5-shim');

using nodejs 4.4.5

Hi,

I'm trying to play algoritmic music in sync on a network of computers, but with the examples of express and socket provided. The system is constantly quarter of a second out of time when I have this code:

socket = io.connect("http://192.168.0.100:3000"); // This connects the sockets to my server

But when I leave it on localhost, then it is in time with the express example, but I have no socket connections then. With the socket example its still about a quarter of a second out of time.

socket = io.connect("http://localhost:3000");

Am I doing something wrong?
I use a combination of Express and Socket for this project.

I hope that anyone can help me with this.
If I need to provide some more info then let me know (this is my first issue).

Geert

I used the socket.io example to implement timesync using basic websockets (not a fan of socket.io's overhead and lack of binary buffers). Here is the gist of the implementation:

Server

socket.on('timesync', data  => socket.send('timesync', {
    id: data && data.id || null,
    result: Date.now()
}));

Client

const ts = require('timesync').create({server: socket});
ts.send = (socket, data) => socket.send('timesync', data); // Sends {jsonrpc: "2.0", id: null, result: <timestamp>}
socket.on('timesync', data => ts.receive(null, data)); // Receives {id: null, result: <timestamp>}

The issue is that hundreds of timesync requests are being sent per second, even though each is receiving a correct response. I have tried create({server: socket, interval: 5000}) as in the socket.io example, but am getting the same result. I'm not sure if I'm missing something, or if there's a bug. Any help would be appreciated.

When using this library the frontend will throw an error when using react native. This is because of the way that the request file checks that the typeof window is not undefined

https://github.com/enmasseio/timesync/blob/master/src/request/request.js

The package at "node_modules/timesync/lib/request/request.node.js" attempted to import the Node standard library module "http". 
It failed because the native React runtime does not include the Node standard library. 
Failed building JavaScript bundle.

There is a fork of this project for react native but its outdated and not on npm, so I though that I would bring this up here as it seems like a simple fix.

Here is one stack overflow answer with a fix - This should work as it was added by react native to differentiate between itself and node - discussed here

if (typeof document != 'undefined') {
  // I'm on the web!
}
else if (typeof navigator != 'undefined' || navigator.product == 'ReactNative') {
  // I'm in react-native
}
else {
  // I'm in node js
}

So we could make it something like:

if (typeof document != 'undefined' && navigator.product == 'ReactNative') {
  // I'm in browser or react-native
 isBrowser=true
}
else {
  // I'm in node js
 isBrowser=false
}

Or another way to do it would be to check whether it has the node only default modules like http that could also be another good way to differentiate

Using timesync with bodyParser.json makes node.js freeze after few timesync requests.
I init timesync & bodyParser like this:

var bodyParser = require('body-parser')
app.use(bodyParser.json({type: 'application/json'}));
app.use('/timesync', timesync.requestHandler);

Using timesync brings in Promise.js and emitter.js, which are files which a browser will not need. It would be great to be able to use timesync without bringing in these unnecessary files.

Like your implementation however I noticed that median is currently just returning the median element of the unsorted array not the sorted array and is thus giving incorrect results:

The current implementation:

export function median (arr) {
  if (arr.length < 2) return arr[0];

  var sorted = arr.slice().sort(compare);
  if (sorted.length % 2 === 0) {
    // even
    return (arr[arr.length / 2 - 1] + arr[arr.length / 2]) / 2;
  }
  else {
    // odd
    return arr[(arr.length - 1) / 2];
  }

Proposed fix:

export function median (arr) {
  if (arr.length < 2) return arr[0];

  var sorted = arr.slice().sort(compare);
  if (sorted.length % 2 === 0) {
    // even
    return (sorted [sorted .length / 2 - 1] + sorted [sorted .length / 2]) / 2;
  }
  else {
    // odd
    return sorted [(sorted .length - 1) / 2];
  }

I'm getting "Unable to resolve module 'http'" in my React Native app.
It is not present in node_modules indeed.
Where does it come from ?

Thanks.

code snippet from /server/index.js

exports.requestHandler = function (req, res) {
  debug('request ' + req.method + ' ' + req.url + ' ' + req.method);

  if (req.method == 'POST') {
    if (!filename) {
      // a time request
      return sendTimestamp(req, res);
    }
  }

  if (req.method == 'GET') {
    var match = req.url.match(/\/(timesync(.min)?.js)$/);
    var filename = match && match[1];
    if (filename === 'timesync.js' || filename === 'timesync.min.js') {
      // static file handler
      return sendFile(res, __dirname + '/../dist/' + filename);
    }
  }

  res.writeHead(404);
  res.end('Not found');
};

Hi,
is it possible to add an option to have a synchronization with a high precision, kind real time ?

Somme time I have less than 100ms between my differents clients, and on the next sync I have more than 600ms.

I need to play different part of video on different glued screen. Same thing when I need to play a set of images

Thank in advance

index.js needs to return some extra headers for this to work, here.

Let me know if you're willing to merge a PR for this and I'll write one up.