| <?php␊ |
| /* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */␊ |
| /*␊ |
| # ***** BEGIN LICENSE BLOCK *****␊ |
| # This file is part of Plume Framework, a simple PHP Application Framework.␊ |
| # Copyright (C) 2001-2010 Loic d'Anterroches and contributors.␊ |
| #␊ |
| # Plume Framework is free software; you can redistribute it and/or modify␊ |
| # it under the terms of the GNU Lesser General Public License as published by␊ |
| # the Free Software Foundation; either version 2.1 of the License, or␊ |
| # (at your option) any later version.␊ |
| #␊ |
| # Plume Framework is distributed in the hope that it will be useful,␊ |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of␊ |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the␊ |
| # GNU Lesser General Public License for more details.␊ |
| #␊ |
| # You should have received a copy of the GNU Lesser General Public License␊ |
| # along with this program; if not, write to the Free Software␊ |
| # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA␊ |
| #␊ |
| # ***** END LICENSE BLOCK ***** */␊ |
| ␊ |
| /**␊ |
| * Core A/B testing component.␊ |
| *␊ |
| * The two importants methods are `test` and `convert`.␊ |
| *␊ |
| * For performance reasons, the A/B testing component requires you to␊ |
| * setup a cache (APC or Memcached) and use the MongoDB database. The␊ |
| * amount of data in the MongoDB should not be that big for most of␊ |
| * the websites and as such it is fine if you are using the 32bit␊ |
| * version of MongoDB.␊ |
| *␊ |
| * For the moment the storage is not abstracted to use another database.␊ |
| *␊ |
| * All the configuration variables for the component start with␊ |
| * `pluf_ab_`. You need to add 'Pluf_AB' to your list of middleware.␊ |
| *␊ |
| */␊ |
| class Pluf_AB␊ |
| {␊ |
| /**␊ |
| * MongoDB database handler.␊ |
| */␊ |
| public static $db = null;␊ |
| ␊ |
| /**␊ |
| * Returns an alternative for a given test.␊ |
| * ␊ |
| * The middleware is already storing the uid of the user and makes␊ |
| * it available as $request->pabuid.␊ |
| *␊ |
| * @param $test string Unique name of the test␊ |
| * @param $request Pluf_HTTP_Request␊ |
| * @param $alts array Alternatives to pick from (array(true,false))␊ |
| * @param $weights array Weights for the alternatives (null)␊ |
| * @param $desc string Optional description of the test ('')␊ |
| * @return mixed One value from $alts␊ |
| */␊ |
| public static function test($test, &$request, $alts=array(true,false), ␊ |
| $weights=null, $desc='')␊ |
| {␊ |
| if (Pluf::f('pluf_ab_allow_force', false) and ␊ |
| isset($request->GET[$test])) {␊ |
| return $alts[$request->GET[$test]];␊ |
| }␊ |
| $db = self::getDb();␊ |
| // Get or set test␊ |
| $dtest = $db->tests->findOne(array('_id' => $test), ␊ |
| array('_id', 'active', 'winner'));␊ |
| if ($dtest == null) {␊ |
| $dtest = array('_id' => $test,␊ |
| 'creation_dtime' => gmdate('Y-m-d H:i:s', ␊ |
| $request->time),␊ |
| 'desc' => $desc,␊ |
| 'alts' => $alts,␊ |
| 'exp' => 0,␊ |
| 'conv' => 0,␊ |
| 'active' => true);␊ |
| for ($i=0;$i<count($alts);$i++) {␊ |
| $dtest['expalt_'.$i] = 0;␊ |
| $dtest['convalt_'.$i] = 0;␊ |
| }␊ |
| $db->tests->update(array('_id'=>$test), $dtest,␊ |
| array('upsert' => true));␊ |
| } elseif (!$dtest['active']) {␊ |
| // If test closed with given alternative, returns alternative␊ |
| return (isset($dtest['winner'])) ? $alts[$dtest['winner']] : $alts[0];␊ |
| }␊ |
| if (!isset($request->pabuid)) {␊ |
| $request->pabuid = self::getUid($request);␊ |
| }␊ |
| if ($request->pabuid == 'bot') {␊ |
| return $alts[0];␊ |
| }␊ |
| // If $request->pabuid in test, returns corresponding alternative␊ |
| $intest = $db->intest->findOne(array('_id' => $test.'##'.$request->pabuid), ␊ |
| array('_id', 'alt'));␊ |
| if ($intest) {␊ |
| return $alts[$intest['alt']];␊ |
| }␊ |
| // Else find alternative, store and return it␊ |
| if ($weights == null) {␊ |
| $weights = array_fill(0, count($alts), 1.0/count($alts));␊ |
| }␊ |
| $alt = self::weightedRand($weights);␊ |
| $intest = array('_id' => $test.'##'.$request->pabuid, ␊ |
| 'test' => $test,␊ |
| 'pabuid' => $request->pabuid, ␊ |
| 'first_dtime' => gmdate('Y-m-d H:i:s', ␊ |
| $request->time),␊ |
| 'alt' => $alt);␊ |
| $db->intest->update(array('_id' => $test.'##'.$request->pabuid),␊ |
| $intest, array('upsert' => true));␊ |
| // Update the counts of the test␊ |
| $db->tests->update(array('_id' => $test), ␊ |
| array('$inc' => array('exp' => 1, ␊ |
| 'expalt_'.$alt => 1)));␊ |
| return $alts[$alt];␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Mark a test as converted.␊ |
| *␊ |
| * A user which was not exposed to the test or a bot is not marked␊ |
| * as converted as it is not significant.␊ |
| *␊ |
| * @param $test string Test␊ |
| * @param $request Pluf_HTTP_Request␊ |
| */␊ |
| public static function convert($test, $request)␊ |
| {␊ |
| if (!isset($request->pabuid) or $request->pabuid == 'bot') {␊ |
| return;␊ |
| }␊ |
| $db = self::getDb();␊ |
| $id = $test.'##'.$request->pabuid;␊ |
| $intest = $db->intest->findOne(array('_id' => $id), ␊ |
| array('_id', 'alt'));␊ |
| if (!$intest) {␊ |
| // Not tested␊ |
| return;␊ |
| }␊ |
| $conv = $db->convert->findOne(array('_id' => $id)); ␊ |
| if ($conv) {␊ |
| // Already converted␊ |
| return;␊ |
| }␊ |
| $dtest = $db->tests->findOne(array('_id' => $test)); ␊ |
| if (!$dtest or !$dtest['active']) {␊ |
| return;␊ |
| }␊ |
| $conv = array(␊ |
| '_id' => $id,␊ |
| 'test' => $test,␊ |
| );␊ |
| $db->convert->update(array('_id' => $id), $conv, ␊ |
| array('upsert' => true));␊ |
| // increment the test counters␊ |
| $db->tests->update(array('_id' => $test), ␊ |
| array('$inc' => array('conv' => 1, ␊ |
| 'convalt_'.$intest['alt'] => 1)));␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Process the response of a view.␊ |
| *␊ |
| * If the request has no cookie and the request has a pabuid, set␊ |
| * the cookie in the response. ␊ |
| *␊ |
| * @param Pluf_HTTP_Request The request␊ |
| * @param Pluf_HTTP_Response The response␊ |
| * @return Pluf_HTTP_Response The response␊ |
| */␊ |
| function process_response($request, $response)␊ |
| {␊ |
| if (!isset($request->COOKIE['pabuid']) and isset($request->pabuid)␊ |
| and $request->pabuid != 'bot') {␊ |
| $response->cookies['pabuid'] = $request->pabuid;␊ |
| }␊ |
| return $response;␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Process the request.␊ |
| *␊ |
| * If the request has the A/B test cookie, set $request->pabuid.␊ |
| *␊ |
| * @param Pluf_HTTP_Request The request␊ |
| * @return bool False␊ |
| */␊ |
| function process_request($request)␊ |
| {␊ |
| if (isset($request->COOKIE['pabuid']) and␊ |
| self::check_uid($request->COOKIE['pabuid'])) {␊ |
| $request->pabuid = $request->COOKIE['pabuid'];␊ |
| }␊ |
| return false;␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Get a MongoDB database handle.␊ |
| *␊ |
| * It opens only one connection per request and tries to keep a␊ |
| * persistent connection between the requests.␊ |
| *␊ |
| * The configuration keys used are:␊ |
| *␊ |
| * `pluf_ab_mongo_server`: 'mongodb://localhost:27017'␊ |
| * `pluf_ab_mongo_options`: array('connect' => true, ␊ |
| * 'persist' => 'pluf_ab_mongo')␊ |
| * `pluf_ab_mongo_db`: 'pluf_ab'␊ |
| *␊ |
| * If you have a default installation of MongoDB, it should work␊ |
| * out of the box. ␊ |
| *␊ |
| */␊ |
| public static function getDb()␊ |
| {␊ |
| if (self::$db !== null) {␊ |
| return self::$db;␊ |
| }␊ |
| $server = Pluf::f('pluf_ab_mongo_server', 'mongodb://localhost:27017');␊ |
| $options = Pluf::f('pluf_ab_mongo_options', ␊ |
| array('connect' => true, 'persist' => 'pluf_ab_mongo'));␊ |
| $conn = new Mongo($server, $options); ␊ |
| self::$db = $conn->selectDB(Pluf::f('pluf_ab_mongo_db', 'pluf_ab'));␊ |
| return self::$db;␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Get the uid of a given request.␊ |
| *␊ |
| * @param $request Pluf_HTTP_Request␊ |
| */␊ |
| public static function getUid($request)␊ |
| {␊ |
| if (isset($request->COOKIE['pabuid']) and ␊ |
| self::check_uid($request->COOKIE['pabuid'])) {␊ |
| return $request->COOKIE['pabuid'];␊ |
| }␊ |
| if (!isset($request->SERVER['HTTP_USER_AGENT']) or␊ |
| self::isBot($request->SERVER['HTTP_USER_AGENT'])) {␊ |
| return 'bot';␊ |
| }␊ |
| // Here we need to make an uid, first check if a user with␊ |
| // same ip/agent exists and was last seen within the last 1h.␊ |
| // We get that from MemcacheDB␊ |
| $cache = Pluf_Cache::factory();␊ |
| $key = 'pluf_ab_'.crc32($request->remote_addr.'#'.$request->SERVER['HTTP_USER_AGENT']);␊ |
| if ($uid=$cache->get($key, null)) {␊ |
| $cache->set($key, $uid, 3600);␊ |
| return $uid;␊ |
| }␊ |
| $uid = self::make_uid($request);␊ |
| $cache->set($key, $uid, 3600);␊ |
| return $uid;␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Check if a given user agent is a bot.␊ |
| *␊ |
| * @param $user_agent string User agent string␊ |
| * @return bool True if the user agent is a bot␊ |
| */␊ |
| public static function isBot($user_agent)␊ |
| {␊ |
| static $bots = array('robot', 'checker', 'crawl', 'discovery', ␊ |
| 'hunter', 'scanner', 'spider', 'sucker', 'larbin',␊ |
| 'slurp', 'libwww', 'lwp', 'yandex', 'netcraft',␊ |
| 'wget', 'twiceler');␊ |
| static $pbots = array('/bot[\s_+:,\.\;\/\\\-]/i', ␊ |
| '/[\s_+:,\.\;\/\\\-]bot/i');␊ |
| foreach ($bots as $r) {␊ |
| if (false !== stristr($user_agent, $r)) {␊ |
| return true;␊ |
| }␊ |
| }␊ |
| foreach ($pbots as $p) {␊ |
| if (preg_match($p, $user_agent)) {␊ |
| return true;␊ |
| }␊ |
| }␊ |
| if (false === strpos($user_agent, '(')) {␊ |
| return true;␊ |
| }␊ |
| return false;␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Returns a random weighted alternative.␊ |
| *␊ |
| * Given a series of weighted alternative in the format:␊ |
| * ␊ |
| * <pre>␊ |
| * array('alt1' => 0.2,␊ |
| * 'alt2' => 0.3,␊ |
| * 'alt3' => 0.5);␊ |
| * </pre>␊ |
| *␊ |
| * Returns the key of the selected alternative. In the following␊ |
| * example, the alternative 3 (alt3) has a 50% chance to be␊ |
| * selected, if the selected the results would be 'alt3'.␊ |
| ␊ |
| * @link: http://20bits.com/downloads/w_rand.phps␊ |
| *␊ |
| * @param $weights array Weighted alternatives␊ |
| * @return mixed Key of the selected $weights array␊ |
| */␊ |
| public static function weightedRand($weights) ␊ |
| {␊ |
| $r = mt_rand(1,10000);␊ |
| $offset = 0;␊ |
| foreach ($weights as $k => $w) {␊ |
| $offset += $w*10000;␊ |
| if ($r <= $offset) {␊ |
| return $k;␊ |
| }␊ |
| }␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Given a request, make a corresponding A/B test UID.␊ |
| *␊ |
| * The UID is based on the time, the remote address, a random␊ |
| * component and is hashed to ensure the integrity and avoid the␊ |
| * need of a database hit when controlled.␊ |
| *␊ |
| * @param $request Pluf_HTTP_Request␊ |
| * @return string UID␊ |
| */␊ |
| public static function make_uid($request)␊ |
| {␊ |
| $base = sprintf('%08X%08X%08X', $request->time, ␊ |
| sprintf('%u', crc32($request->remote_addr)), ␊ |
| rand());␊ |
| return sprintf('%s%08X', $base, sprintf('%u', crc32($base.md5(Pluf::f('secret_key')))));␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Validate the uid in the cookie. ␊ |
| *␊ |
| * @see self::make_uid␊ |
| *␊ |
| * @param $uid string The UID␊ |
| * @return bool True if the UID is valid␊ |
| */␊ |
| public static function check_uid($uid)␊ |
| {␊ |
| if (strlen($uid) != 32) {␊ |
| return false;␊ |
| }␊ |
| $check = sprintf('%08X', sprintf('%u', crc32(substr($uid, 0, 24).md5(Pluf::f('secret_key')))));␊ |
| return ($check == substr($uid, -8));␊ |
| }␊ |
| ␊ |
| /* ------------------------------------------------------------␊ |
| *␊ |
| * Statistics Functions␊ |
| *␊ |
| * Note: I am not a statistician, use at your own risk!␊ |
| *␊ |
| * ------------------------------------------------------------ */␊ |
| ␊ |
| /**␊ |
| * Given a conversion rate calculate the recommended sample sizes.␊ |
| *␊ |
| * The sample sizes is calculated to be significant at 95% in the␊ |
| * case of a variation of conversion with respect to the other␊ |
| * alternative of 25%, 15% and 5%.␊ |
| *␊ |
| * @param $conv Conversion rate ]0.0;1.0]␊ |
| * @return array The 3 sample sizes for 25%, 15% and 5%␊ |
| */␊ |
| public static function ssize($conv)␊ |
| {␊ |
| $a = 3.84145882689; // $a = pow(inverse_ncdf(1-(1-0.95)/2),2)␊ |
| $res = array();␊ |
| $bs = array(0.0625, 0.0225, 0.0025);␊ |
| foreach ($bs as $b) {␊ |
| $res[] = (int) ((1-$conv)*$a/($b*$conv));␊ |
| }␊ |
| return $res;␊ |
| }␊ |
| ␊ |
| ␊ |
| /**␊ |
| * Given a test, returns the corresponding stats.␊ |
| *␊ |
| * @param $test array Test definition and results␊ |
| * @return array Statistics for the test␊ |
| */␊ |
| public static function getTestStats($test)␊ |
| {␊ |
| $stats = array(); // Will store the stats␊ |
| $n = count($test['alts']);␊ |
| $aconvr = array(); // All the conversion rates to sort the alternatives␊ |
| for ($i=0;$i<$n;$i++) {␊ |
| $conv = (isset($test['convalt_'.$i])) ? $test['convalt_'.$i] : 0;␊ |
| $exp = (isset($test['expalt_'.$i])) ? $test['expalt_'.$i] : 0;␊ |
| $convr = self::cr(array($exp, $conv));␊ |
| $nconvr = ($convr !== null) ?␊ |
| sprintf('%01.2f%%', $convr*100.0) : 'N/A';␊ |
| $ssize = ($convr !== null and $convr > 0) ?␊ |
| self::ssize($convr) : array();␊ |
| $stats[] = array('alt' => $i,␊ |
| 'convr' => $convr,␊ |
| 'conv' => $conv,␊ |
| 'exp' => $exp,␊ |
| 'nconvr' => $nconvr,␊ |
| 'ssize' => $ssize);␊ |
| $aconvr[] = ($convr === null) ? 0 : $convr;␊ |
| }␊ |
| array_multisort($aconvr, SORT_DESC, $stats);␊ |
| // We want the best to be significantly better than the second best.␊ |
| for ($i=0;$i<$n;$i++) {␊ |
| $convr = $stats[$i]['convr'];␊ |
| $exp = $stats[$i]['exp'];␊ |
| $conv = $stats[$i]['conv'];␊ |
| $comp = false;␊ |
| $zscore = false;␊ |
| $conf = false;␊ |
| $better = false;␊ |
| if ($i != 1 and $stats[1]['convr'] > 0) {␊ |
| // Compare with base case and get confidence/Z-score␊ |
| $comp = 100.0 * (float) ($convr - $stats[1]['convr'])/ (float) ($stats[1]['convr']);␊ |
| if ($comp > 0) $better = true;␊ |
| $comp = sprintf('%01.2f%%', $comp); ␊ |
| $zscore = self::zscore(array($stats[1]['exp'], $stats[1]['conv']), ␊ |
| array($exp, $conv));␊ |
| $conf = sprintf('%01.2f%%', self::cumnormdist($zscore)*100.0);␊ |
| $zscore = sprintf('%01.2f', $zscore);␊ |
| }␊ |
| $stats[$i]['comp'] = $comp;␊ |
| $stats[$i]['zscore'] = $zscore;␊ |
| $stats[$i]['conf'] = $conf;␊ |
| $stats[$i]['better'] = $better;␊ |
| }␊ |
| return $stats;␊ |
| }␊ |
| ␊ |
| public static function cr($t) ␊ |
| { ␊ |
| if ($t[1] < 0) return null;␊ |
| if ($t[0] <= 0) return null;␊ |
| return $t[1]/$t[0]; ␊ |
| }␊ |
| ␊ |
| public static function zscore($c, $t) ␊ |
| {␊ |
| $z = self::cr($t)-self::cr($c);␊ |
| $s = (self::cr($t)*(1-self::cr($t)))/$t[0] ␊ |
| + (self::cr($c)*(1-self::cr($c)))/$c[0];␊ |
| return $z/sqrt($s);␊ |
| }␊ |
| ␊ |
| /**␊ |
| * Approximation of the cumulative normal distribution.␊ |
| */␊ |
| public static function cumnormdist($x)␊ |
| {␊ |
| $b1 = 0.319381530;␊ |
| $b2 = -0.356563782;␊ |
| $b3 = 1.781477937;␊ |
| $b4 = -1.821255978;␊ |
| $b5 = 1.330274429;␊ |
| $p = 0.2316419;␊ |
| $c = 0.39894228;␊ |
| ␊ |
| if($x >= 0.0) {␊ |
| $t = 1.0 / ( 1.0 + $p * $x );␊ |
| return (1.0 - $c * exp( -$x * $x / 2.0 ) * $t *␊ |
| ( $t *( $t * ( $t * ( $t * $b5 + $b4 ) + $b3 ) + $b2 ) + $b1 ));␊ |
| } else {␊ |
| $t = 1.0 / ( 1.0 - $p * $x );␊ |
| return ( $c * exp( -$x * $x / 2.0 ) * $t *␊ |
| ( $t *( $t * ( $t * ( $t * $b5 + $b4 ) + $b3 ) + $b2 ) + $b1 ));␊ |
| }␊ |
| }␊ |
| }␊ |
accountmanagementengine