PHP Function to generate an infinite unique indentifier

This should be a comment, but its a bit long.

There is some confusion over your use of "unique" and "all the time". A token is either unique or it is not. Using a random number generator to create tokens alone is not sufficient to guarantee uniqueness - the whole point of a random number generator is that you don't know what the next value to be generated will be - meaning you also don't know that the next number won't be the same as a previous number. OTOH, using random_bytes() or openssl_random_pseudo_bytes() to generate a token which is "99% unique all the time" seems like a massive overkill.

To work out how unique this is likely to be we would need to know how many tokens will be considered within the populations at any one time (or to be able to calculate this from the expected rate of creation and the TTL).

That you are using large numbers rather implies you have a very good reason for not using the simplest and most obvious unique identifier - i.e. an incrementing integer. Hence the resistance to guessing an existing identifier is clearly critical to the implementation - but again you've told us nothing about that.

Pasting the title of your post into Google turns up your post as the top result - with PHP's uniqid() function immediately after it - yet for some reason you've either not found uniqid() or have rejected it for some reason.

The title of your post is also an oxymoron - In order to define an infinite set of identifiers, the identifiers would need to be of infinite length.

it needs to be able to generate hundreds, millions of "hashes"

....and you want it all to run within the Zend Framework? - LOL.

But I cannot confirm that this does guarantee me a 99% success rate for my production environment.

Why not? You have sufficient information here to confirm that the bitwise entropy is evenly distributed and should know the planned capacity of the production environment. The rest is basic arithmetic.

We are about 8x10⁹ people. Imagine all us access your site once each second needing a unique identifier during a year. You need about 2,52288×10²³ identifiers. If you think your site will be in production about 1000 years, and population get bigger by a 1000 factor you need about 10²⁹ identifiers; so a 32 bytes auto-incremental string is good enough. Add as suffix a pseudo-random 32 bytes string to get a secure 64 bytes identifier. Doing a bit plus you can hash identifiers to create tokens.

Then is easy to write a function to get them.

Edited 2017/04/13 A small sample: The first thing you need is a pseudo-random strong keys generator. I'll post the function I'm using currently:

<?php
function pseudoRandomBytes($count = 32){
  static $random_state, $bytes, $has_openssl, $has_hash;
  $missing_bytes = $count - strlen($bytes);
  if ($missing_bytes > 0) {
  // If you are using a Php version before 5.3.4 avoid using
  // openssl_random_pseudo_bytes()
    if (!isset($has_openssl)) {
      $has_openssl = version_compare(PHP_VERSION, '5.3.4', '>=') 
                   && function_exists('openssl_random_pseudo_bytes');
    }
    // to get entropy
    if ($has_openssl) {
      $bytes .= openssl_random_pseudo_bytes($missing_bytes);
    } elseif ($fh = @fopen('/dev/urandom', 'rb')) {
      // avoiding openssl_random_pseudo_bytes()
      // you find entropy at /dev/urandom usually available in most
      // *nix systems
      $bytes .= fread($fh, max(4096, $missing_bytes));
      fclose($fh);
    }
    // If it fails you must create enough entropy
    if (strlen($bytes) < $count) {
      // Initialize on the first call. The contents of $_SERVER 
      // includes a mix of user-specific and system information 
      // that varies a little with each page.
      if (!isset($random_state)) {
        $random_state = print_r($_SERVER, TRUE);
        if (function_exists('getmypid')) {
          // Further initialize with the somewhat random PHP process ID.
          $random_state .= getmypid();
        }
        // hash() is only available in PHP 5.1.2+ or via PECL.
        $has_hash = function_exists('hash') 
                  && in_array('sha256', hash_algos());
        $bytes = '';
      }
      if ($has_hash) {
        do {
          $random_state = hash('sha256', microtime() . mt_rand() . 
          $random_state);
          $bytes .= hash('sha256', mt_rand() . $random_state, TRUE);
        } while (strlen($bytes) < $count);
      } else {
        do {
          $random_state = md5(microtime() . mt_rand() . $random_state);
          $bytes .= pack("H*", md5(mt_rand() . $random_state));
        } while (strlen($bytes) < $count);
      }
    }
  }
  $output = substr($bytes, 0, $count);
  $bytes = substr($bytes, $count);
  return $output;
}

Once you have that function you need a function to create your random keys:

<?php
function pseudo_random_key($byte_count = 32) {
  return base64_encode(pseudoRandomBytes($byte_count));
}

As random does not mean unique! you need to merge a unique 32 bytes prefix as I suggested. As big number functions are time-expensive I'll use a chunk-math function using a prefix I suppose generated from time to time using a cron function and stored at an environment DB variable and an auto-incremental index also db-stored

<?php
function uniqueChunkMathKeysPrefix(){
  // a call to read your db for prefix
  // I suppose you have an environment string-keyed table
  // and a couple of dbfunction to read and write data to it
  $last18bytesPrefix = dbReadEnvVariable('unique_prefix');
  // Also you store your current index wich returns to 0 once you get
  // a 99999999999999 value
  $lastuniqueindex = dbReadEnvVariable('last_unique_keys_index');
  if ($lastuniqueindex < 99999999999999){
    $currentuniqueindex = $lastuniqueindex + 1;
    $curret18bytesPrefix = $last18bytesPrefix;
  }else{
    $currentuniqueindex = 0;
    $curret18bytesPrefix = dbReadEnvVariable('next_unique_prefix');
    // flag your db variables to notify cron to create a new next prefix
    dbStoreEnvVariable('next_unique_prefix', 0);
    dbStoreEnvVariable('unique_prefix', $curret18bytesPrefix);
    // you have the time needed to have site visits and create new 
    // 99999999999999 keys as a while to run your cron to adjust your 
    // next prefix
  }
  // store your current index
  dbStoreEnvVariable('last_unique_keys_index', $currentuniqueindex);
  // Finally you create the unique index prefix part
  $uniqueindexchunk = substr('00000000000000'.$currentuniqueindex, -14);
  // return the output
  return $curret18bytesPrefix.$uniqueindexchunk;
}

Now you can write a function for unique pseudo-random 64 bytes uniquekeys

<?php
function createUniquePseudoRandomKey(){
  $newkey = uniqueChunkMathKeysPrefix() . pseudo_random_key(32);
  // to beautify the output make a dummie call
  // masking the 0s ties
  return md5($newkey);
}