UUID which version to use to avoid collisions - guid

Question

In my system, people use different devices (which works online and offline) to create entries(stored locally until synced) and they get synced with other devices and the server periodically. For this reason, I have to use UUID so that each device can generate a UUID to identify a record and subrecords under it so that it can be synced with other devices once it's synced with the server. So far, it's working well. The only problem is that I got a collision. Even though there are only 400k records in the system, I am wondering this could happen more often.
I am using https://github.com/monicao/angular-uuid4 version 4. Should I use version 1 instead? Each device usually generate none to few UUID per minute, so no chance of split second generation on a single device. These UUID will always be generated from client side and not by server side.
What is the best way to reduce the chance of collisions here assuming no evil/malicious clients and the UUID is system generated and it doesn't matter if it can be traced?

Answer 1

The issue seems to be with the implementation of the library you are using.
Since you are already storing ids with 128 bit precision (stored as 16 chars, not the 36 chars used to encode as a string with hexadecimal values and dashes), you can simply use this for your id generator:
// Returns a 128 bit random id encoded as hexadecimal values.
string randomId() {
const bytes = new Uint8Array(16)
crypto.getRandomBytes(bytes)
return Array.from(bytes, b => ('0' + b.toString(16)).slice(-2)).join('')
}
But this is bad for your database so to improve things, you can use a number of bytes to add locality:
const LOCALITY_BYTES = 4
const RESOLUTION = 500 // [ms]
// 4 bytes with 500 ms resolution gives 68 years modulo.
const MODULO = Math.pow(2, LOCALITY_BYTES * 8)
function locality() {
let date = Math.floor(Date.now() / RESOLUTION) % MODULO
const bytes = []
for (let i = 0; i < LOCALITY_BYTES; ++i) {
const b = date % 256
bytes.unshift(b)
date = (date - b) / 256
}
return bytes
}
function randomIdWithLocality() {
const bytes = new Uint8Array(16)
crypto.getRandomValues(bytes)
bytes.set(locality())
return Array.from(bytes, b => ('0' + b.toString(16)).slice(-2)).join('')
}
With this implementation, you have "only" 96 bits of randomness per 500 ms timeframe compared to v4 122 bits (for the whole life of your app). These 96 bits give you a 50% chance of having at least 1 collision if you write 3 * 10^14 records in 500 ms instead of v4's 2.6 * 10^18 for your app's duration v4 uuid.