├── .env.example
├── .gitignore
├── README.md
├── app
    ├── App.php
    ├── Controllers
    │   ├── Controller.php
    │   └── Home
    │   │   └── Index.php
    ├── Exceptions
    │   └── Handler.php
    ├── Helpers
    │   ├── Config.php
    │   ├── DebugBar.php
    │   ├── Helper.php
    │   ├── Log.php
    │   ├── Repository.php
    │   └── function.php
    ├── Middlewares
    │   └── AuthMiddleware.php
    ├── Models
    │   ├── Models.php
    │   └── User.php
    ├── Routes
    │   └── web.php
    └── Routing
    │   └── Router.php
├── composer.json
├── index.php
├── mdcalls
    ├── Basic
    │   ├── Exception.php
    │   └── MdCallsBasic.php
    ├── Config
    │   ├── app.php
    │   ├── database.php
    │   ├── queue.php
    │   └── redis.php
    ├── MdCalls.php
    └── Service
    │   └── Kick
    │       ├── Child
    │           ├── Queue.php
    │           ├── Queue
    │           │   ├── Job.php
    │           │   └── Worker.php
    │           └── Storage.php
    │       └── KickIndex.php
├── public
    ├── index.php
    ├── views
    │   ├── Admin
    │   │   └── index.html
    │   └── Home
    │   │   └── index.html
    └── xhprof
    │   ├── xhprof_html
    │       ├── callgraph.php
    │       ├── css
    │       │   └── xhprof.css
    │       ├── docs
    │       │   ├── index-fr.html
    │       │   ├── index.html
    │       │   ├── sample-callgraph-image.jpg
    │       │   ├── sample-diff-report-flat-view.jpg
    │       │   ├── sample-diff-report-parent-child-view.jpg
    │       │   ├── sample-flat-view.jpg
    │       │   └── sample-parent-child-view.jpg
    │       ├── index.php
    │       ├── jquery
    │       │   ├── indicator.gif
    │       │   ├── jquery-1.2.6.js
    │       │   ├── jquery.autocomplete.css
    │       │   ├── jquery.autocomplete.js
    │       │   ├── jquery.tooltip.css
    │       │   └── jquery.tooltip.js
    │       ├── js
    │       │   └── xhprof_report.js
    │       └── typeahead.php
    │   └── xhprof_lib
    │       ├── display
    │           ├── typeahead_common.php
    │           └── xhprof.php
    │       └── utils
    │           ├── callgraph_utils.php
    │           ├── xhprof_lib.php
    │           └── xhprof_runs.php
└── storage
    ├── cache
        └── .gitignore
    └── logs
        └── .gitignore


/.env.example:
--------------------------------------------------------------------------------
 1 | # web 环境是否为 debug
 2 | APP_DEBUG=false
 3 | 
 4 | DB_CONNECTION=default.master
 5 | DB_HOST=192.168.10.10
 6 | DB_PORT=3306
 7 | DB_DATABASE=geermall_psbildr
 8 | DB_USERNAME=homestead
 9 | DB_PASSWORD=secret
10 | 
11 | REDIS_HOST=127.0.0.1
12 | REDIS_PASSWORD=null
13 | REDIS_PORT=6379


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | vendor/*
2 | .DS_Store
3 | .idea/*
4 | composer.lock
5 | .env
6 | storage/views/
7 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # KickPeach
  2 | 
  3 | > 一个提供模块化服务的现代PHP小框架
  4 | 
  5 | 
  6 | 正如在框架设计的初心上所说，市面上已经那么多的框架了，还造什么轮子，再次重申一下。造轮子不是目的，造轮子的过程中汲取到知识才是目的，共勉。
  7 | 
  8 | 框架的使用文档以及组件文档可访问[https://kickpeach.github.io/](https://kickpeach.github.io/)
  9 | 
 10 | ## 框架示例网站
 11 | 
 12 | [http://wdzs.xhzyxed.cn/](http://wdzs.xhzyxed.cn/)
 13 | 
 14 | 
 15 | ## 框架的组织方式
 16 | 
 17 | kickpeach项目目录参考Laravel的文件组织方式进行组织，采取组件化开发，灵活扩展升级每个组件，主要由以下几个组件完成：
 18 | 
 19 | 可查看[组织](https://github.com/KickPeach)进行源码的阅读
 20 | 
 21 | ```cmd
 22 | Kickpeach　
 23 |         kickPeach----> 最终可以使用的框架,也就是当前所在项目
 24 |         framework----> 框架的核心文件
 25 |         queue----> 任务队列组件
 26 |         database----> 数据库组件
 27 |         mdCalls----> 提供模块化服务的组件
 28 |         kickpeach.github.io---->框架的使用文档
 29 | ```
 30 | 
 31 | 其他模块都有模块的文档
 32 | 
 33 | ## 框架的设计思路
 34 | 
 35 | ```cmd
 36 | 
 37 | 入口文件
 38 |         ----> 注册错误(和异常)处理函数
 39 |         ----> 加载配置文件
 40 |         ----> 请求
 41 |         ----> 路由　
 42 |         ---->中间件
 43 |         ---->（控制器 <----> 数据模型）
 44 |         ----> 响应
 45 |         ----> 视图渲染数据
 46 | ```
 47 | 
 48 | - 阅读源码的方式
 49 | 
 50 |     composer create kickpeach/kickpeach testkickpeach,composer update下载载源码下来之后，按照上面流程，可以看到框架源码的具体实现，从index.php入口看起。kickpeach只是framework的扩展，基于framework，完全可以自定义有自己风格的框架。
 51 | 核心源码都在framework,在看源码的时候，你就会深入了解到什么叫self,static，继承，抽象，与接口。
 52 | 
 53 | - 模块化组织
 54 |     个人觉得Laravel的容器太重，虽然好用，但是还是不太想用这个，因此，这里使用了MdCalls组件来解决依赖方式，可见框架中mdcalls目录，mdcalls支持rpc与框架内调用，内置了database,queue以及redis服务，具体使用方式可见文档
 55 | 
 56 | - 自动加载
 57 |    
 58 |    使用composer和命名空间，遵循psr-4规范
 59 |    
 60 | - 异常模块
 61 | 
 62 |    错误捕获，异常捕获，让错误可以被异常一样捕捉，并且友好的提示错误，关键函数set_error_handler，set_exception_handler，register_shutdown_function
 63 | 
 64 | - 路由
 65 | 
 66 |    解析请求，基于fastroute组件开发，支持自定义路由以及默认路由，为了不占内存，缓存了路由，获得待处理的的模块，控制器和方法
 67 |    
 68 | - 控制器
 69 | 
 70 |    获取每个控制器定义的中间件，先经过中间件解析处理，最后才控制器
 71 |    
 72 | - 中间件
 73 | 
 74 |    借鉴了Laravel的pipeline编写了路由中间件
 75 |  
 76 | - 响应
 77 | 
 78 |   模板引擎使用twig组件，支持变量赋值以及模板，支持json响应
 79 |   
 80 | - 数据库
 81 | 
 82 |    采用第三方database组件方式，利用mdcalls提供服务
 83 |    
 84 | - 其他友好函数
 85 | 
 86 |   日志工具类，文件读取文件，日志读取类，配置文件读取类
 87 | 
 88 | - queue
 89 | 
 90 |   任务队列组件，支持延时队列以及失败任务重试
 91 |   
 92 | ## TODO
 93 | 
 94 | - [x] 请求参数的验证模块
 95 | - [x] 集成[php-debugbar](https://github.com/maximebf/php-debugbar)
 96 | - [x] 使用kickpeach做一个demo [http://wdzs.xhzyxed.cn/](http://wdzs.xhzyxed.cn/)
 97 | 
 98 | ## 帮助kickpeach改进
 99 | 
100 | 欢迎给Kickpeach提issue:[https://github.com/KickPeach/kickPeach/issues](https://github.com/KickPeach/kickPeach/issues)
101 |   
102 | 
103 | # License
104 | 
105 | The MIT License (MIT).
106 | 


--------------------------------------------------------------------------------
/app/App.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/2
 6 |  * Time: 19:22
 7 |  */
 8 | 
 9 | namespace App;
10 | 
11 | use Kickpeach\Framework\Foundation\Application;
12 | use MdCalls\MdCalls;
13 | use App\Exceptions\Handler;
14 | use App\Routing\Router;
15 | use DebugBar\StandardDebugBar;
16 | 
17 | 
18 | 
19 | class App extends Application
20 | {
21 |     private $mdc;
22 | 
23 |     public $debugbar;
24 | 
25 |     public $debugbaRender;
26 | 
27 | 
28 |     protected $config = [
29 |         'debug'         => true,
30 |         'Version'     => 'KPramework/1.0',
31 |         'timezone'      => 'PRC',
32 |         'view'          => [
33 |             'cache'     => __DIR__ . '/../storage/views',
34 |         ],
35 |         'xhprof_dir'    => __DIR__ . '/../public/xhprof',
36 | 
37 |     ];
38 | 
39 |     protected function __construct()
40 |     {
41 |         parent::__construct();
42 |         $this->mdc = MdCalls::getInstance();
43 |         $this->config = array_merge($this->config,$this->mdc->Kick->getConf('app'));
44 | 
45 |         $this->debugbar = new StandardDebugBar();
46 | 
47 |         $this->debugbaRender = $this->debugbar->getJavascriptRenderer();
48 |     }
49 | 
50 |     public function getMdc()
51 |     {
52 |         return $this->mdc;
53 |     }
54 | 
55 |     protected function setExceptionsHandler()
56 |     {
57 |         return new Handler($this->config('debug'), '', $this->config('Version'));
58 |     }
59 | 
60 |     protected function initRouter()
61 |     {
62 |         $this->router = new Router(dirname(__DIR__) . '/storage/cache/route.cache');
63 |     }
64 | 
65 |     //全局中间件
66 |     protected $middleware = [
67 | //        \Kickpeach\Framework\Foundation\Middleware\Xhprof::class,
68 |     ];
69 | }


--------------------------------------------------------------------------------
/app/Controllers/Controller.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/4
 6 |  * Time: 11:20
 7 |  */
 8 | 
 9 | namespace App\Controllers;
10 | use App\App;
11 | use Kickpeach\Framework\Routing\Controller as BasicController;
12 | 
13 | 
14 | abstract class Controller extends BasicController
15 | {
16 |     //所有控制器都可以通过mdc访问服务
17 |     private $db;
18 |     private $redis;
19 |     private $mdc;
20 | 
21 |     public function __construct(App $app)
22 |     {
23 |         parent::__construct($app);
24 |         $this->db = $app->getMdc()->Kick->loadDB();
25 |         $this->redis = $app->getMdc()->Kick->loadRedis();
26 |         $this->mdc = $app->getMdc();
27 |     }
28 | 
29 |     //模板渲染
30 |     protected function render($tpl,$data=[]){
31 |         $loader = new \Twig_Loader_Filesystem(__DIR__.'/../../public/views');
32 |         $twig = new \Twig_Environment($loader,[
33 |             'cache'=>$this->app->config('view.cache'),
34 |             'debug'=>$this->app->config('debug')
35 |         ]);
36 | 
37 |         return $twig->load($tpl)->render($data);
38 |     }
39 | 
40 |     //获取db实例
41 |     protected function db()
42 |     {
43 |         return $this->db;
44 |     }
45 | 
46 |     //获取redis实例
47 |     protected function redis()
48 |     {
49 |         return $this->redis;
50 |     }
51 | 
52 |     //获取mdc实例
53 |     protected function getMdc()
54 |     {
55 |         return $this->mdc;
56 |     }
57 | 
58 | }


--------------------------------------------------------------------------------
/app/Controllers/Home/Index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/4
 6 |  * Time: 13:51
 7 |  */
 8 | 
 9 | namespace App\Controllers\Home;
10 | use App\Controllers\Controller;
11 | use App\Helpers;
12 | use KickPeach\Validate\Validate;
13 | use KickPeach\Validate\ValidateException;
14 | 
15 | 
16 | class Index extends Controller
17 | {
18 |     protected static $middleware = [
19 |         'index'=>[
20 |             'App\Middlewares\AuthMiddleware'
21 |         ]
22 |     ];
23 | 
24 |     public function index()
25 |     {
26 |         try {
27 |             $data = Validate::validated(['name'=>''],['name'=>'required']);
28 |         }catch (ValidateException $exception){
29 |             Helpers\Helper::fail(101,$exception->getMessage());
30 |         }
31 |         $name = 'KickPeach';
32 |         return $this->render('/Home/index.html',compact('name'));    }
33 | 
34 |     public function test()
35 |     {
36 | 
37 |         Helpers\Helper::success(['name'=>'seven']);
38 |     }
39 | 
40 | }


--------------------------------------------------------------------------------
/app/Exceptions/Handler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/2
 6 |  * Time: 19:44
 7 |  */
 8 | 
 9 | namespace App\Exceptions;
10 | 
11 | use Kickpeach\Framework\Foundation\Exceptions\HttpException;
12 | use Kickpeach\Framework\Foundation\Exceptions\Handler as ExceptionsHandler;
13 | use App\Helpers\Log;
14 | 
15 | class Handler extends ExceptionsHandler
16 | {
17 |     protected $debug;
18 | 
19 |     public function __construct($debug =false,$collapseDir = '', $cfVersion = 'KickPeach/1.0')
20 |     {
21 |         $this->debug = $debug;
22 |         parent::__construct($collapseDir, $cfVersion);
23 |     }
24 | 
25 |     /**
26 |      * 错误的日志记录
27 |      */
28 |     protected function report($e)
29 |     {
30 |         $content = $this->getLogOfException($e);
31 | 
32 |         Log::error($content);
33 |     }
34 | 
35 |     /**
36 |      * @param $e
37 |      * 渲染错误页面
38 |      */
39 |     protected function renderWebException($e)
40 |     {
41 |         if ($this->debug){
42 |             parent::renderWebException($e);
43 |         }else{
44 |             $this->renderError($e);
45 |         }
46 |     }
47 | 
48 |     protected function renderError($e)
49 |     {
50 |         $statusCode = 500;
51 |         if ($e instanceof HttpException){
52 |             $statusCode = $e->getStatusCode();
53 |         }
54 | 
55 |         if (!headers_sent()){
56 |             header("HTTP/1.0 {$statusCode} " . 'Internal Server Error');
57 |         }
58 |         echo <<<EOF
59 | <style type="text/css">
60 | *{ padding: 0; margin: 0; }
61 | body{padding: 24px 48px; background: #fff; font-family: "微软雅黑"; color: #333;}
62 | h1{ font-size: 90px; font-weight: normal;}
63 | p{ line-height: 1.8em; font-size: 24px }
64 | </style>
65 | <h1>:(</h1>
66 | <p>哦豁，服务器开小差了.</p>
67 | EOF;
68 |     }
69 | 
70 | 
71 | }


--------------------------------------------------------------------------------
/app/Helpers/Config.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 21:58
 7 |  */
 8 | 
 9 | namespace App\Helpers;
10 | 
11 | 
12 | /**
13 |  * 框架配置辅助类
14 |  */
15 | class Config
16 | {
17 |     /**
18 |      * All of the loaded configuration files.
19 |      *
20 |      * @var array
21 |      */
22 |     protected $loadedConfigurations = [];
23 |     /**
24 |      * config 目录
25 |      */
26 |     private $configDir;
27 |     /**
28 |      * 配置的数据仓库
29 |      */
30 |     private $repository;
31 |     /**
32 |      * Config constructor.
33 |      *
34 |      * @param $configDir string 配置文件夹
35 |      */
36 |     public function __construct($configDir)
37 |     {
38 |         $this->configDir = realpath($configDir);
39 |         $this->repository = new Repository;
40 |     }
41 |     /**
42 |      * 获取配置
43 |      *
44 |      * @param $item string 配置选项
45 |      * @param mixed $default 默认值
46 |      *
47 |      * @return mixed
48 |      */
49 |     public function get($item, $default = null)
50 |     {
51 |         $segments = explode('.', $item, 2);
52 |         $this->load($segments[0]);
53 |         return $this->repository->get($item, $default);
54 |     }
55 |     /**
56 |      * 动态修改配置
57 |      *
58 |      * @param $name string 如 'main',
59 |      * @return void
60 |      */
61 |     protected function load($name)
62 |     {
63 |         if (isset($this->loadedConfigurations[$name])) {
64 |             return;
65 |         }
66 |         $this->loadedConfigurations[$name] = true;
67 |         $file = $this->configDir . '/' . $name . '.php';
68 |         $this->repository->set($name, require $file);
69 |     }
70 |     /**
71 |      * 动态修改配置
72 |      *
73 |      * @param $item string
74 |      * @param $config mixed 配置值
75 |      * @return void
76 |      */
77 |     public function set($item, $config)
78 |     {
79 |         $segments = explode('.', $item, 2);
80 |         $this->load($segments[0]);
81 |         $this->repository->set($item, $config);
82 |     }
83 | }


--------------------------------------------------------------------------------
/app/Helpers/DebugBar.php:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 
 3 | <head>
 4 | 
 5 |     <?php echo App\App::getInstance()->debugbaRender->renderHead() ?>
 6 | 
 7 | </head>
 8 | 
 9 | <body>
10 | 
11 | <?php echo App\App::getInstance()->debugbaRender->render() ?>
12 | 
13 | </body>
14 | 
15 | </html>


--------------------------------------------------------------------------------
/app/Helpers/Helper.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Created by PhpStorm.
  4 |  * User: seven
  5 |  * Date: 2019/2/11
  6 |  * Time: 22:32
  7 |  */
  8 | 
  9 | namespace App\Helpers;
 10 | 
 11 | 
 12 | class Helper
 13 | {
 14 |     public static function dd(...$vars)
 15 |     {
 16 |         foreach ($vars as $v) {
 17 |             var_dump($v);
 18 |         }
 19 |         die(1);
 20 |     }
 21 |     /**
 22 |      * Gets the value of an environment variable.
 23 |      *
 24 |      * @param  string  $key
 25 |      * @param  mixed   $default
 26 |      * @return mixed
 27 |      */
 28 |     public static function env($key, $default = null)
 29 |     {
 30 |         $value = getenv($key);
 31 |         if ($value === false) {
 32 |             return $default;
 33 |         }
 34 |         switch (strtolower($value)) {
 35 |             case 'true':
 36 |                 return true;
 37 |             case 'false':
 38 |                 return false;
 39 |             case 'empty':
 40 |                 return '';
 41 |             case 'null':
 42 |                 return;
 43 |         }
 44 |         if (($valueLength = strlen($value)) > 1 && $value[0] === '"' && $value[$valueLength - 1] === '"') {
 45 |             return substr($value, 1, -1);
 46 |         }
 47 |         return $value;
 48 |     }
 49 | 
 50 |     public static function getAllHeader()
 51 |     {
 52 |         $headers = [];
 53 |         foreach ($_SERVER as $name => $value)
 54 |         {
 55 |             if (substr($name, 0, 5) == 'HTTP_')
 56 |             {
 57 |                 $headers[str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, 5)))))] = $value;
 58 |             }
 59 |         }
 60 |         return $headers;
 61 |     }
 62 | 
 63 |     public static function getUserAgent()
 64 |     {
 65 |         $headers = self::getAllHeader();
 66 |         $userAgent = isset($headers['User-Agent']) ? $headers['User-Agent'] : (isset($headers['user-agent']) ? $headers['user-agent'] : '');
 67 | 
 68 |         if (empty($userAgent))
 69 |         {
 70 |             return null;
 71 |         }
 72 | 
 73 |         $ua = array();
 74 |         $ua['browser'] = $userAgent;
 75 |         $type = "";
 76 |         if (strpos($userAgent, 'MSIE') != false)
 77 |         {
 78 |             $ua['ua'] = 'IE';
 79 |             //$ua['version'] = self::findUserAgentByKey($userAgent, );
 80 |             $type = "MSIE";
 81 |         }
 82 |         else if (strpos($userAgent, 'Gecko/') != false)
 83 |         {
 84 |             $ua['ua'] = 'firefox';
 85 |             $type = 'Firefox/';
 86 |         }
 87 |         else if (strpos($userAgent, 'AppleWebKit/') != false)
 88 |         {
 89 |             if (strpos($userAgent, 'Chrome') != false)
 90 |             {
 91 |                 $ua['ua'] = 'chrome';
 92 |                 $type = 'Chrome/';
 93 |             }
 94 |             else
 95 |             {
 96 |                 $ua['ua'] = 'safari';
 97 |                 $type = 'Version/';
 98 |             }
 99 |         }
100 |         else if (strpos($userAgent, 'Presto/') != false)
101 |         {
102 |             $ua['ua'] = 'opera';
103 |             $type = 'Opera/';
104 |         }
105 |         else if (strpos($userAgent, 'Trident') != false)
106 |         {
107 |             $ua['ua'] = 'IE';
108 |             $type = 'rv:';
109 |         }
110 |         else if (strpos($userAgent, 'MobileSafari') != false)
111 |         {
112 |             $ua['ua'] = 'MobileSafari';
113 |             $type = 'MobileSafari/';
114 |         }
115 |         else
116 |         {
117 |             $ua['ua'] = 'unknown';
118 |         }
119 |         if ($type != '')
120 |         {
121 |             $ua['version'] = self::findUserAgentByKey($userAgent, $type);
122 |         }
123 |         return $ua;
124 |     }
125 | 
126 |     public static  function findUserAgentByKey($ua, $key)
127 |     {
128 |         $ua .= " ";
129 |         $len = strlen($key);
130 |         $start = strpos($ua, $key);
131 |         $pos = strpos($ua, ' ', $start + $len + 1);
132 |         $version = substr($ua, $start + $len, $pos - $len - $start);
133 |         return str_replace(array(';', ')'), '', $version);
134 |     }
135 | 
136 |     public static function isAjaxRequest()
137 |     {
138 |         return isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_X_REQUESTED_WITH']==='XMLHttpRequest';
139 | 
140 |     }
141 | 
142 |     public static function redirect($url)
143 |     {
144 |         header('Location: '.$url);
145 |         exit();
146 |     }
147 | 
148 |     private static function json($code, $msg, $data = null, $return = false)
149 |     {
150 |         $result = ['code' => $code, 'msg' => $msg, 'now' => date('Y-m-d H:i:s')];
151 | 
152 |         if ($data !== null)
153 |             $result['data'] = $data;
154 | 
155 |         $json = json_encode($result);
156 | 
157 |         if($json === false && json_last_error() != JSON_ERROR_NONE) {
158 |             throw new \Exception(json_last_error_msg());
159 |         }
160 | 
161 |         if ($return) return $json;
162 | 
163 |         $ua = \App\Helpers\Helper::getUserAgent();
164 | 
165 |         if (isset($ua['ua']) && $ua['ua'] == 'IE' && !self::isAjaxRequest())
166 |             header('Content-type: text/plain');
167 |         else
168 |             header('Content-type: application/json');
169 | 
170 |         echo $json;
171 |         exit();
172 |     }
173 | 
174 |     public static function success($data, $return = false)
175 |     {
176 |         return self::json(0, 'success', $data, $return);
177 |     }
178 | 
179 |     public static function fail($code, $msg, $return = false)
180 |     {
181 |         return self::json($code, $msg, null, $return);
182 |     }
183 | }


--------------------------------------------------------------------------------
/app/Helpers/Log.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/4
 6 |  * Time: 9:11
 7 |  */
 8 | 
 9 | namespace App\Helpers;
10 | 
11 | use Kickpeach\Framework\surpport\Helpers\Logger;
12 | 
13 | class Log extends Logger
14 | {
15 |     protected  function getLogPath($dir)
16 |     {
17 |         return $dir.'/'.date('Ym').'/';
18 |     }
19 | 
20 |     protected function getStoragePath()
21 |     {
22 |         return dirname(dirname(__DIR__)).'/storage';
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/app/Helpers/Repository.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Created by PhpStorm.
  4 |  * User: seven
  5 |  * Date: 2019/2/11
  6 |  * Time: 22:22
  7 |  */
  8 | 
  9 | namespace App\Helpers;
 10 | 
 11 | use ArrayAccess;
 12 | use Kickpeach\Framework\surpport\Helpers\Arr;
 13 | 
 14 | class Repository implements ArrayAccess
 15 | {
 16 |     /**
 17 |      * All of the configuration items.
 18 |      *
 19 |      * @var array
 20 |      */
 21 |     protected $items = [];
 22 |     /**
 23 |      * Create a new configuration repository.
 24 |      *
 25 |      * @param  array  $items
 26 |      * @return void
 27 |      */
 28 |     public function __construct(array $items = [])
 29 |     {
 30 |         $this->items = $items;
 31 |     }
 32 |     /**
 33 |      * Determine if the given configuration value exists.
 34 |      *
 35 |      * @param  string  $key
 36 |      * @return bool
 37 |      */
 38 |     public function has($key)
 39 |     {
 40 |         return Arr::has($this->items, $key);
 41 |     }
 42 |     /**
 43 |      * Get all of the configuration items for the application.
 44 |      *
 45 |      * @return array
 46 |      */
 47 |     public function all()
 48 |     {
 49 |         return $this->items;
 50 |     }
 51 |     /**
 52 |      * Get the specified configuration value.
 53 |      *
 54 |      * @param  string  $key
 55 |      * @param  mixed   $default
 56 |      * @return mixed
 57 |      */
 58 |     public function get($key = null, $default = null)
 59 |     {
 60 |         return Arr::get($this->items, $key, $default);
 61 |     }
 62 |     /**
 63 |      * Set a given configuration value.
 64 |      *
 65 |      * @param  array|string  $key
 66 |      * @param  mixed   $value
 67 |      * @return void
 68 |      */
 69 |     public function set($key, $value = null)
 70 |     {
 71 |         if (is_array($key)) {
 72 |             foreach ($key as $innerKey => $innerValue) {
 73 |                 Arr::set($this->items, $innerKey, $innerValue);
 74 |             }
 75 |         } else {
 76 |             Arr::set($this->items, $key, $value);
 77 |         }
 78 |     }
 79 |     /**
 80 |      * Prepend a value onto an array configuration value.
 81 |      *
 82 |      * @param  string  $key
 83 |      * @param  mixed  $value
 84 |      * @return void
 85 |      */
 86 |     public function prepend($key, $value)
 87 |     {
 88 |         $array = $this->get($key);
 89 |         array_unshift($array, $value);
 90 |         $this->set($key, $array);
 91 |     }
 92 |     /**
 93 |      * Push a value onto an array configuration value.
 94 |      *
 95 |      * @param  string  $key
 96 |      * @param  mixed  $value
 97 |      * @return void
 98 |      */
 99 |     public function push($key, $value)
100 |     {
101 |         $array = $this->get($key);
102 |         $array[] = $value;
103 |         $this->set($key, $array);
104 |     }
105 |     /**
106 |      * Determine if the given configuration option exists.
107 |      *
108 |      * @param  string  $key
109 |      * @return bool
110 |      */
111 |     public function offsetExists($key)
112 |     {
113 |         return $this->has($key);
114 |     }
115 |     /**
116 |      * Get a configuration option.
117 |      *
118 |      * @param  string  $key
119 |      * @return mixed
120 |      */
121 |     public function offsetGet($key)
122 |     {
123 |         return $this->get($key);
124 |     }
125 |     /**
126 |      * Set a configuration option.
127 |      *
128 |      * @param  string  $key
129 |      * @param  mixed  $value
130 |      * @return void
131 |      */
132 |     public function offsetSet($key, $value)
133 |     {
134 |         $this->set($key, $value);
135 |     }
136 |     /**
137 |      * Unset a configuration option.
138 |      *
139 |      * @param  string  $key
140 |      * @return void
141 |      */
142 |     public function offsetUnset($key)
143 |     {
144 |         $this->set($key, null);
145 |     }
146 | }


--------------------------------------------------------------------------------
/app/Helpers/function.php:
--------------------------------------------------------------------------------
1 | <?php
2 | /**
3 |  * Created by PhpStorm.
4 |  * User: seven
5 |  * Date: 2019/1/4
6 |  * Time: 13:59
7 |  */


--------------------------------------------------------------------------------
/app/Middlewares/AuthMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: shisiying
 5 |  * Date: 2019-03-29
 6 |  * Time: 22:56
 7 |  */
 8 | 
 9 | namespace App\Middlewares;
10 | 
11 | use Closure;
12 | use Kickpeach\Framework\Contracts\Application;
13 | 
14 | class AuthMiddleware
15 | {
16 |     public function handle(Application $app, Closure $next)
17 |     {
18 |         if (false) {
19 |             \App\Helpers\Helper::redirect('/home/index/test');
20 |         }
21 |         $response = $next($app);
22 |         return $response;
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/app/Models/Models.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/14
 6 |  * Time: 11:31
 7 |  */
 8 | 
 9 | namespace App\Models;
10 |  use MdCalls\MdCalls;
11 | 
12 | abstract class Models
13 | {
14 |     private  $db;
15 | 
16 |     public function __construct()
17 |     {
18 |         $this->db = MdCalls::getInstance()->Kick->loadDB();
19 |     }
20 | 
21 |     public function db()
22 |     {
23 |         return $this->db;
24 |     }
25 | 
26 | }


--------------------------------------------------------------------------------
/app/Models/User.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/14
 6 |  * Time: 11:36
 7 |  */
 8 | 
 9 | namespace App\Models;
10 | 
11 | 
12 | class User extends Models
13 | {
14 |     public  function getAllUsers()
15 |     {
16 |         return $this->db()->select('select * from users order by id desc limit 1');
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/app/Routes/web.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/4
 6 |  * Time: 10:34
 7 |  */
 8 | 
 9 | //$this->any('/home/{id:[0-9]+}/user/{uid}', [
10 | //         'uses'=> 'Home\Index@index',
11 | //]);


--------------------------------------------------------------------------------
/app/Routing/Router.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/2
 6 |  * Time: 19:51
 7 |  */
 8 | 
 9 | namespace App\Routing;
10 | 
11 | use Kickpeach\Framework\Routing\Router as BaseRouter;
12 | 
13 | class Router extends BaseRouter
14 | {
15 |     /**
16 |      * 获取路由定义
17 |      */
18 |     protected function getRouteDefinition()
19 |     {
20 |         //先加载自定义的
21 |         if (PHP_SAPI!='cli'){
22 |             require __DIR__ . '/../Routes/web.php';
23 |         }
24 |         //再加载tp式的路由形式
25 |         parent::getRouteDefinition();
26 |     }
27 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "kickpeach/kickpeach",
 3 |     "description": "a micro php framework project based on my own php framework.",
 4 |     "type": "project",
 5 |     "license": "MIT",
 6 |     "authors": [
 7 |         {
 8 |             "name": "shisiying",
 9 |             "email": "shisiying@xhzyxed.cn"
10 |         }
11 |     ],
12 |     "require": {
13 |         "php": ">=5.6",
14 |         "kickpeach/framework": "dev-master",
15 |         "twig/twig": "~2.0",
16 |         "kickpeach/database": "dev-master",
17 |         "kickpeach/queue": "dev-master",
18 |         "kickpeach/mdcalls": "dev-master",
19 |         "vlucas/phpdotenv": "^3.3@dev",
20 |         "predis/predis": "^2.0@dev",
21 |         "maximebf/debugbar": "^1.15@dev",
22 |         "kickpeach/validate": "dev-master"
23 | 
24 |     },
25 |     "autoload": {
26 |         "psr-4": {
27 |             "App\\": "app/",
28 |             "MdCalls\\": "mdcalls/"
29 |         }
30 |     },
31 |     "minimum-stability":"dev"
32 | }
33 | 


--------------------------------------------------------------------------------
/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/4
 6 |  * Time: 9:06
 7 |  */
 8 | 
 9 | require_once __DIR__.'/public/index.php';
10 | 


--------------------------------------------------------------------------------
/mdcalls/Basic/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 21:00
 7 |  */
 8 | 
 9 | namespace MdCalls\Basic;
10 | 
11 | use kickPeach\mdCalls\Exceptions\MdCallsException;
12 | 
13 | class Exception extends MdCallsException
14 | {
15 |     public function __construct($message = '', $code = 0)
16 |     {
17 |         parent::__construct($message, $code);
18 |     }
19 | }


--------------------------------------------------------------------------------
/mdcalls/Basic/MdCallsBasic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 20:59
 7 |  */
 8 | 
 9 | namespace MdCalls\Basic;
10 | 
11 | use kickPeach\mdCalls\Basic\MdCallsBasic as Basic;
12 | 
13 | abstract class MdCallsBasic extends Basic
14 | {
15 | }


--------------------------------------------------------------------------------
/mdcalls/Config/app.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 23:13
 7 |  */
 8 | return [
 9 |     'debug' => App\Helpers\Helper::env('APP_DEBUG'),
10 | ];


--------------------------------------------------------------------------------
/mdcalls/Config/database.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 22:16
 7 |  */
 8 | 
 9 | return [
10 |     'default' => array(
11 |         'master' => [  //默认数据库
12 |             'driver'    => 'mysql',
13 |             'host'      => App\Helpers\Helper::env('DB_HOST'),
14 |             'port'      => App\Helpers\Helper::env('DB_PORT'),
15 |             'database'  => App\Helpers\Helper::env('DB_DATABASE'),
16 |             'username'  => App\Helpers\Helper::env('DB_USERNAME'),
17 |             'password'  => App\Helpers\Helper::env('DB_PASSWORD'),
18 |             'charset'   => 'utf8mb4',
19 |         ],
20 |         'slave' => [
21 |             'driver'    => 'mysql',
22 |             'host'      => App\Helpers\Helper::env('DB_HOST'),
23 |             'port'      => App\Helpers\Helper::env('DB_PORT'),
24 |             'database'  => App\Helpers\Helper::env('DB_DATABASE'),
25 |             'username'  => App\Helpers\Helper::env('DB_USERNAME'),
26 |             'password'  => App\Helpers\Helper::env('DB_PASSWORD'),
27 |             'charset'   => 'utf8mb4',
28 |         ]
29 |     ),
30 |     // 'MDB_MISSION'
31 |     'user' => [
32 |         'master' => [  //默认数据库
33 |             'driver'    => 'pgsql',
34 |             'host'      => App\Helpers\Helper::env('DB_HOST'),
35 |             'port'      => App\Helpers\Helper::env('DB_PORT'),
36 |             'database'  => App\Helpers\Helper::env('DB_DATABASE'),
37 |             'username'  => App\Helpers\Helper::env('DB_USERNAME'),
38 |             'password'  => App\Helpers\Helper::env('DB_PASSWORD'),
39 |         ],
40 |         'slave' => [
41 |             'driver'    => 'pgsql',
42 |             'host'      => App\Helpers\Helper::env('DB_HOST'),
43 |             'port'      => App\Helpers\Helper::env('DB_PORT'),
44 |             'database'  => App\Helpers\Helper::env('DB_DATABASE'),
45 |             'username'  => App\Helpers\Helper::env('DB_USERNAME'),
46 |             'password'  => App\Helpers\Helper::env('DB_PASSWORD'),
47 |         ]
48 |     ],
49 | ];


--------------------------------------------------------------------------------
/mdcalls/Config/queue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 22:17
 7 |  */
 8 | 
 9 | return [
10 |     'default'   => [
11 |         'driver'    => 'beanstalkd',
12 |         'host'      => '127.0.0.1',
13 |         'port'      => '11300',
14 |     ],
15 | ];


--------------------------------------------------------------------------------
/mdcalls/Config/redis.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 22:17
 7 |  */
 8 | 
 9 | return array(
10 |     'default'  => array(    //默认redis
11 |         'host'      => App\Helpers\Helper::env('REDIS_HOST'),
12 |         'port'      => App\Helpers\Helper::env('REDIS_PORT'),
13 |         'timeout'   => 3,
14 |     ),
15 | );


--------------------------------------------------------------------------------
/mdcalls/MdCalls.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 20:52
 7 |  */
 8 | 
 9 | namespace MdCalls;
10 | 
11 | use kickPeach\mdCalls\MdCallsService;
12 | 
13 | 
14 | class MdCalls extends MdCallsService
15 | {
16 |     protected static $mdCallsInstance;
17 | 
18 |     protected $mdCallsNamespace = 'MdCalls';
19 | }


--------------------------------------------------------------------------------
/mdcalls/Service/Kick/Child/Queue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 22:05
 7 |  */
 8 | 
 9 | namespace MdCalls\Service\Kick\Child;
10 | 
11 | use MdCalls\Basic\MdCallsBasic;
12 | use MdCalls\Service\Kick\Child\Queue\Job;
13 | use MdCalls\Service\Kick\Child\Queue\Worker;
14 | use KickPeach\Queue\Drivers\Beanstalkd;
15 | use KickPeach\Queue\Queue as QueueService;
16 | 
17 | class Queue extends MdCallsBasic
18 | {
19 |     public function init()
20 |     {
21 |     }
22 | 
23 |     public function invokeRpc($method, $args)
24 |     {
25 |     }
26 | 
27 |     /**
28 |      * 队列连接 实例，所有子类都会共享该属性
29 |      */
30 |     private static $connObj = array();
31 |     /**
32 |      * @param string $conn
33 |      * @return QueueService
34 |      */
35 |     public function getQueue($conn = 'default')
36 |     {
37 |         if (! isset(self::$connObj[$conn])) {
38 |             $config = $this->mdc->Kick->getConf('queue.' . $conn);
39 |             self::$connObj[$conn] = new QueueService(new Beanstalkd($config['host'], $config['port']));
40 |         }
41 |         return self::$connObj[$conn];
42 |     }
43 |     /**
44 |      * @param Job $job
45 |      * @return mixed
46 |      */
47 |     public function dispatch(Job $job)
48 |     {
49 |         return $this->getQueue($job->connection)->push($job);
50 |     }
51 |     /**
52 |      * @param $delay
53 |      * @param Job $job
54 |      * @return mixed
55 |      */
56 |     public function laterDispatch($delay, Job $job)
57 |     {
58 |         return $this->getQueue($job->connection)->later($delay, $job);
59 |     }
60 |     /**
61 |      *
62 |      * Listen to the given queue in a loop.
63 |      *
64 |      * @param $connection
65 |      * @param string $queueTube
66 |      * @param int $sleep 没有新的有效任务产生时的休眠时间 (单位: 秒)
67 |      * @param int $memoryLimit worker 内存限制 (单位: mb)
68 |      */
69 |     public function daemon($connection = 'default', $queueTube = '', $sleep = 60, $memoryLimit = 128)
70 |     {
71 |         $worker = new Worker($this->getQueue($connection), $queueTube);
72 |         $worker->setMdCalls($this->mdc);
73 |         $worker->daemon($sleep, $memoryLimit);
74 |     }
75 | 
76 | 
77 | }


--------------------------------------------------------------------------------
/mdcalls/Service/Kick/Child/Queue/Job.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 22:06
 7 |  */
 8 | 
 9 | namespace MdCalls\Service\Kick\Child\Queue;
10 | 
11 | use KickPeach\Queue\Job as BasicJob;
12 | 
13 | abstract class Job extends BasicJob
14 | {
15 |     public $connection = 'default';
16 | 
17 |     public $mdc;
18 | }


--------------------------------------------------------------------------------
/mdcalls/Service/Kick/Child/Queue/Worker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 22:06
 7 |  */
 8 | 
 9 | namespace MdCalls\Service\Kick\Child\Queue;
10 | 
11 | use KickPeach\Queue\Worker as BasicWorker;
12 | use KickPeach\Queue\Job;
13 | use MdCalls\MdCalls;
14 | 
15 | class Worker extends BasicWorker
16 | {
17 |     private $mdc;
18 | 
19 |     public function setMdCalls(MdCalls $mdc)
20 |     {
21 |         $this->mdc = $mdc;
22 |     }
23 | 
24 |     protected function logProcessError(\Exception $e)
25 |     {
26 |         parent::logProcessError($e);
27 |     }
28 | 
29 |     protected function handleWithObj(Job $obj)
30 |     {
31 |         $obj->mdc = $this->mdc;
32 |         parent::handleWithObj($obj);
33 |     }
34 | 
35 |     protected function queueShouldRestart($startTime)
36 |     {
37 |         return false;
38 |     }
39 | 
40 | }


--------------------------------------------------------------------------------
/mdcalls/Service/Kick/Child/Storage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/2/11
 6 |  * Time: 21:19
 7 |  */
 8 | 
 9 | namespace MdCalls\Service\Kick\Child;
10 | 
11 | use KickPeach\DataBase\MysqlConnection;
12 | use KickPeach\DataBase\PostpostgresqlConnection;
13 | use Predis\Client as Redis;
14 | use MdCalls\Basic\MdCallsBasic;
15 | 
16 | class Storage extends MdCallsBasic
17 | {
18 | 
19 |     /**
20 |      * @var array 单例属性，所有子类都会共享该属性
21 |      */
22 |     private static $dbObj = [];
23 | 
24 |     public function init()
25 |     {
26 |     }
27 | 
28 |     public function invokeRpc($method, $args)
29 |     {
30 |     }
31 | 
32 |     /**
33 |      * 构造函数
34 |      */
35 |     public function __construct()
36 |     {
37 |     }
38 | 
39 |     /**
40 |      * 加载数据库mysql获取数据库操作对象
41 |      * $this->loadDB();
42 |      * $this->loadDB('mission.slave');
43 |      *
44 |      * @param string $database
45 |      * @return \Jetea\Database\Connection
46 |      */
47 |     public function db($database = 'default.master')
48 |     {
49 |         if (! isset(self::$dbObj[$database])) {
50 |             $config = $this->mdc->Kick->getConf('database.' . $database);
51 |             if ($config['driver'] == 'mysql') {
52 |                 $dsn = sprintf('mysql:host=%s;port=%s;dbname=%s;charset=%s', $config['host'], $config['port'], $config['database'], $config['charset']);
53 |                 $connection = new MySqlConnection($dsn, $config['username'], $config['password']);
54 |             } else {    //默认Pgsql
55 |                 $dsn = sprintf('pgsql:host=%s;port=%s;dbname=%s', $config['host'], $config['port'], $config['database']);
56 |                 $connection = new PostpostgresqlConnection($dsn, $config['username'], $config['password']);
57 |             }
58 |             self::$dbObj[$database] = $connection;
59 |         }
60 |         return self::$dbObj[$database];
61 |     }
62 |     /**
63 |      * redis实例
64 |      */
65 |     private static $redisObj = [];
66 |     /**
67 |      * 加载Redis对象
68 |      * @param string $redis
69 |      * @return Redis
70 |      */
71 |     public function redis($redis = 'default')
72 |     {
73 |         if (! isset(self::$redisObj[$redis])) {
74 |             $config = $this->mdc->Kick->getConf('redis.' . $redis);
75 |             self::$redisObj[$redis] = new Redis([
76 |                 'scheme'    => 'tcp',
77 |                 'host'      => $config['host'],
78 |                 'port'      => $config['port'],
79 |                 'timeout'   => $config['timeout'],
80 |             ]);
81 |         }
82 |         return self::$redisObj[$redis];
83 |     }
84 |     public function __destruct()
85 |     {
86 |         foreach (self::$redisObj as $redis) {
87 |             /** @var $redis Redis */
88 |             $redis->disconnect();
89 |         }
90 |     }
91 | }


--------------------------------------------------------------------------------
/mdcalls/Service/Kick/KickIndex.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Created by PhpStorm.
  4 |  * User: seven
  5 |  * Date: 2019/2/11
  6 |  * Time: 21:06
  7 |  */
  8 | 
  9 | namespace MdCalls\Service\Kick;
 10 | use Dotenv\Dotenv;
 11 | use MdCalls\Basic\MdCallsBasic;
 12 | use App\Helpers\Config;
 13 | 
 14 | class KickIndex extends MdCallsBasic
 15 | {
 16 |     public function init()
 17 |     {
 18 |         Dotenv::create(__DIR__ . '/../../../','.env')->load();//所有.env文件的变量都可以使用getenv($var)获取到
 19 |         $this->config = new Config(__DIR__ . '/../../Config');
 20 |         $this->storage = $this->loadC('Storage');
 21 |         $this->queue = $this->loadC('Queue');    }
 22 | 
 23 |     public function invokeRpc($method, $args)
 24 |     {
 25 |         // TODO: Implement invokeRpc() method.
 26 |     }
 27 | 
 28 |     private $config;
 29 | 
 30 |     private $storage;
 31 | 
 32 |     private $queue;
 33 | 
 34 | 
 35 |     /**
 36 |      * 获取配置
 37 |      *
 38 |      * @param $item
 39 |      * @param mixed $default
 40 |      * @return mixed
 41 |      */
 42 |     public function getConf($item, $default = null)
 43 |     {
 44 |         return $this->config->get($item, $default);
 45 |     }
 46 |     /**
 47 |      * 设置配置
 48 |      *
 49 |      * @param $item
 50 |      * @param mixed $config
 51 |      * @return void
 52 |      */
 53 |     public function setConf($item, $config = null)
 54 |     {
 55 |         $this->config->set($item, $config);
 56 |     }
 57 | 
 58 | 
 59 |     /**
 60 |      * 获取mysql
 61 |      */
 62 |     public function loadDB($database = 'default.master')
 63 |     {
 64 |         return $this->storage->db($database);
 65 |     }
 66 |     /**
 67 |      * 获取redis
 68 |      */
 69 |     public function loadRedis($redis = 'default')
 70 |     {
 71 |         return $this->storage->redis($redis);
 72 |     }
 73 |     /**
 74 |      * @param Job $job
 75 |      * @return mixed
 76 |      */
 77 |     public function dispatch(Job $job)
 78 |     {
 79 |         return $this->queue->dispatch($job);
 80 |     }
 81 |     /**
 82 |      * @param $delay
 83 |      * @param Job $job
 84 |      * @return mixed
 85 |      */
 86 |     public function laterDispatch($delay, Job $job)
 87 |     {
 88 |         return $this->queue->laterDispatch($delay, $job);
 89 |     }
 90 |     /**
 91 |      *
 92 |      * Listen to the given queue in a loop.
 93 |      *
 94 |      * @param $conn
 95 |      * @param string $queueTube
 96 |      * @param int $sleep 没有新的有效任务产生时的休眠时间 (单位: 秒)
 97 |      * @param int $memoryLimit worker 内存限制 (单位: mb)
 98 |      */
 99 |     public function queueDaemon($conn = 'default', $queueTube = '', $sleep = 60, $memoryLimit = 128)
100 |     {
101 |         $this->queue->daemon($conn, $queueTube, $sleep, $memoryLimit);
102 |     }
103 | 
104 | 
105 | }


--------------------------------------------------------------------------------
/public/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: seven
 5 |  * Date: 2019/1/2
 6 |  * Time: 19:15
 7 |  */
 8 | 
 9 | 
10 | require __DIR__.'/../vendor/autoload.php';
11 | 
12 | require_once __DIR__.'/../app/Helpers/function.php';
13 | 
14 | 
15 | \App\App::getInstance()->run();
16 | 
17 | if (\App\App::getInstance()->config('debug')){
18 |     require_once __DIR__.'/../app/Helpers/DebugBar.php';
19 | }
20 | 
21 | 
22 | 
23 | 
24 | 


--------------------------------------------------------------------------------
/public/views/Admin/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <title>Admin</title>
 6 | </head>
 7 | <body>
 8 |     hello {{name}}
 9 | </body>
10 | </html>


--------------------------------------------------------------------------------
/public/views/Home/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 6 | 
 7 |     <title>Kickpeach</title>
 8 | 
 9 |     <!-- Fonts -->
10 |     <link href="https://fonts.googleapis.com/css?family=Nunito:200,600" rel="stylesheet" type="text/css">
11 | 
12 |     <!-- Styles -->
13 |     <style>
14 |         html, body {
15 |             background-color: #fff;
16 |             color: #636b6f;
17 |             font-family: 'Nunito', sans-serif;
18 |             font-weight: 200;
19 |             height: 100vh;
20 |             margin: 0;
21 |         }
22 | 
23 |         .full-height {
24 |             height: 100vh;
25 |         }
26 | 
27 |         .flex-center {
28 |             align-items: center;
29 |             display: flex;
30 |             justify-content: center;
31 |         }
32 | 
33 |         .position-ref {
34 |             position: relative;
35 |         }
36 | 
37 |         .top-right {
38 |             position: absolute;
39 |             right: 10px;
40 |             top: 18px;
41 |         }
42 | 
43 |         .content {
44 |             text-align: center;
45 |         }
46 | 
47 |         .title {
48 |             font-size: 84px;
49 |         }
50 | 
51 |         .links > a {
52 |             color: #636b6f;
53 |             padding: 0 25px;
54 |             font-size: 13px;
55 |             font-weight: 600;
56 |             letter-spacing: .1rem;
57 |             text-decoration: none;
58 |             text-transform: uppercase;
59 |         }
60 | 
61 |         .m-b-md {
62 |             margin-bottom: 30px;
63 |         }
64 |     </style>
65 | 
66 | 
67 | </head>
68 | <body>
69 | <div class="flex-center position-ref full-height">
70 | 
71 |     <div class="content">
72 |         <div class="title m-b-md">
73 |             {{name}}
74 |         </div>
75 | 
76 |         <div class="links">
77 |             <a href="https://kickpeach.github.io/">文档</a>
78 |             <a href="https://github.com/KickPeach/kickPeach">GitHub</a>
79 |             <a href="https://github.com/KickPeach/kickPeach">Demo</a>
80 |         </div>
81 |     </div>
82 | </div>
83 | 
84 | </body>
85 | </html>
86 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/callgraph.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //  Copyright (c) 2009 Facebook
 3 | //
 4 | //  Licensed under the Apache License, Version 2.0 (the "License");
 5 | //  you may not use this file except in compliance with the License.
 6 | //  You may obtain a copy of the License at
 7 | //
 8 | //      http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | //  Unless required by applicable law or agreed to in writing, software
11 | //  distributed under the License is distributed on an "AS IS" BASIS,
12 | //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | //  See the License for the specific language governing permissions and
14 | //  limitations under the License.
15 | //
16 | 
17 | /**
18 |  *
19 |  * A callgraph generator for XHProf.
20 |  *
21 |  * * This file is part of the UI/reporting component,
22 |  *   used for viewing results of XHProf runs from a
23 |  *   browser.
24 |  *
25 |  * Modification History:
26 |  *  02/15/2008 - cjiang  - The first version of callgraph visualizer
27 |  *                         based on Graphviz's DOT tool.
28 |  *
29 |  * @author Changhao Jiang (cjiang@facebook.com)
30 |  */
31 | 
32 | // by default assume that xhprof_html & xhprof_lib directories
33 | // are at the same level.
34 | $GLOBALS['XHPROF_LIB_ROOT'] = dirname(__FILE__) . '/../xhprof_lib';
35 | 
36 | require_once $GLOBALS['XHPROF_LIB_ROOT'].'/display/xhprof.php';
37 | 
38 | ini_set('max_execution_time', 100);
39 | 
40 | $params = array(// run id param
41 |                 'run' => array(XHPROF_STRING_PARAM, ''),
42 | 
43 |                 // source/namespace/type of run
44 |                 'source' => array(XHPROF_STRING_PARAM, 'xhprof'),
45 | 
46 |                 // the focus function, if it is set, only directly
47 |                 // parents/children functions of it will be shown.
48 |                 'func' => array(XHPROF_STRING_PARAM, ''),
49 | 
50 |                 // image type, can be 'jpg', 'gif', 'ps', 'png'
51 |                 'type' => array(XHPROF_STRING_PARAM, 'png'),
52 | 
53 |                 // only functions whose exclusive time over the total time
54 |                 // is larger than this threshold will be shown.
55 |                 // default is 0.01.
56 |                 'threshold' => array(XHPROF_FLOAT_PARAM, 0.01),
57 | 
58 |                 // whether to show critical_path
59 |                 'critical' => array(XHPROF_BOOL_PARAM, true),
60 | 
61 |                 // first run in diff mode.
62 |                 'run1' => array(XHPROF_STRING_PARAM, ''),
63 | 
64 |                 // second run in diff mode.
65 |                 'run2' => array(XHPROF_STRING_PARAM, '')
66 |                 );
67 | 
68 | // pull values of these params, and create named globals for each param
69 | xhprof_param_init($params);
70 | 
71 | // if invalid value specified for threshold, then use the default
72 | if ($threshold < 0 || $threshold > 1) {
73 |   $threshold = $params['threshold'][1];
74 | }
75 | 
76 | // if invalid value specified for type, use the default
77 | if (!array_key_exists($type, $xhprof_legal_image_types)) {
78 |   $type = $params['type'][1]; // default image type.
79 | }
80 | 
81 | $xhprof_runs_impl = new XHProfRuns_Default();
82 | 
83 | if (!empty($run)) {
84 |   // single run call graph image generation
85 |   xhprof_render_image($xhprof_runs_impl, $run, $type,
86 |                       $threshold, $func, $source, $critical);
87 | } else {
88 |   // diff report call graph image generation
89 |   xhprof_render_diff_image($xhprof_runs_impl, $run1, $run2,
90 |                            $type, $threshold, $source);
91 | }
92 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/css/xhprof.css:
--------------------------------------------------------------------------------
 1 | /*  Copyright (c) 2009 Facebook
 2 |  *
 3 |  *  Licensed under the Apache License, Version 2.0 (the "License");
 4 |  *  you may not use this file except in compliance with the License.
 5 |  *  You may obtain a copy of the License at
 6 |  *
 7 |  *      http://www.apache.org/licenses/LICENSE-2.0
 8 |  *
 9 |  *  Unless required by applicable law or agreed to in writing, software
10 |  *  distributed under the License is distributed on an "AS IS" BASIS,
11 |  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 |  *  See the License for the specific language governing permissions and
13 |  *  limitations under the License.
14 |  */
15 | 
16 | td.sorted {
17 |   color:#0000FF;
18 | }
19 | 
20 | td.vbar, th.vbar {
21 |   text-align: right;
22 |   border-left:
23 |   solid 1px #bdc7d8;
24 | }
25 | 
26 | td.vbbar, th.vbar {
27 |   text-align: right;
28 |   border-left:
29 |   solid 1px #bdc7d8;
30 |   color:blue;
31 | }
32 | 
33 | /* diff reports: display regressions in red */
34 | td.vrbar {
35 |   text-align: right;
36 |   border-left:solid 1px #bdc7d8;
37 |   color:red;
38 | }
39 | 
40 | /* diff reports: display improvements in green */
41 | td.vgbar {
42 |   text-align: right;
43 |   border-left: solid 1px #bdc7d8;
44 |   color:green;
45 | }
46 | 
47 | td.vwbar, th.vwbar {
48 |   text-align: right;
49 |   border-left: solid 1px white;
50 | }
51 | 
52 | td.vwlbar, th.vwlbar {
53 |   text-align: left;
54 |   border-left: solid 1px white;
55 | }
56 | 
57 | p.blue  {
58 |   color:blue
59 | }
60 | 
61 | .bubble {
62 |   background-color:#C3D9FF
63 | }
64 | 
65 | ul.xhprof_actions {
66 |   float: right;
67 |   padding-left: 16px;
68 |   list-style-image: none;
69 |   list-style-type: none;
70 |   margin:10px 10px 10px 3em;
71 |   position:relative;
72 | }
73 | 
74 | ul.xhprof_actions li {
75 |   border-bottom:1px solid #D8DFEA;
76 | }
77 | 
78 | ul.xhprof_actions li a:hover {
79 |   background:#3B5998 none repeat scroll 0 0;
80 |   color:#FFFFFF;
81 | }
82 | 
83 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/docs/index-fr.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="fr">
  3 |     <head>
  4 |         <meta charset="utf-8" />
  5 | <title>
  6 | Documentation XHProf (Brouillon)
  7 | </title>
  8 | <body>
  9 | <h3>Documentation XHProf (Brouillon)</h3>
 10 | 
 11 | <b>Sommaire</b>
 12 | <ol>
 13 | <li><a href="#introduction">Introduction</a></li>
 14 | 
 15 | <li><a href="#overview">Présentation</a></li>
 16 | 
 17 | <li><a href="#installation">Installer l’extension XHProf</a></li>
 18 | 
 19 | <li><a href="#using_extension">Profiler avec XHProf</a></li>
 20 | 
 21 | <li><a href="#ui_setup">Définir un environnement graphique pour XHProf</a></li>
 22 | 
 23 | <li><a href="#production_notes">Notes sur l’utilisation d’XHProf en production</a></li>
 24 | 
 25 | <li><a href="#sampling_mode">Mode aléatoire et léger</a>
 26 | 
 27 | <li><a href="#misc">Fonctionnalités supplémentaires</a></li>
 28 | 
 29 | <li><a href="#dependencies">Dépendences</a></li>
 30 | 
 31 | <li><a href="#credits">Remerciements</a></li>
 32 | </ol>
 33 | 
 34 | <ol>
 35 | <li><a name="introduction"><h2>Introduction</h2></a>
 36 | 
 37 | <p>XHProf est un outil de profilage hiérarchique pour PHP. Il relève 
 38 | les appels au niveau des fonctions et mesure <a href="#inclusive">inclusivement</a> et
 39 | <a href="#exclusive">exclusivement</a> des métriques telles que le temps écoulé
 40 | la charge CPU ou l’usage de la mémoire. Un profil de fonction peut être divisé selon ses appelants, ou ses appelés. Le composant qui extrait les données brutes est écrit en C
 41 | et implémenté telle une extension PHP Zend.
 42 | <code><b>xhprof</b></code>. XHProf a une interface utilisateur simple en HTML, (écrite en PHP). 
 43 | L’interface permet de visualiser et de partager facilement le résultat des profilages dans un navigateur.
 44 | Un rendu sous forme de graphique est également disponible.
 45 | 
 46 | <p>Les rapports fournis par XHProf permettent souvent de mieux comprendre 
 47 | la structure du code qui est éxécuté.
 48 | Le rendu hiérarchique des rapports permet par exemple de déterminer 
 49 | quelle chaîne d’appels mène à une fonction particulière.
 50 | 
 51 | <p>XHProf propose également de comparer deux runs (résultat de profilage) 
 52 | pour analyser les différences ou aggréger les résultat de multiples runs afin 
 53 | d’analyser des données consolidées. 
 54 | Les comparaisons et aggrégations de données permettent surtout de visualiser des données plates
 55 | 
 56 | <p>XHProf est un outil de profilage très léger. Pendant la phase de collecte 
 57 | Il garde une trace du nombre d’appels et des métriques inclusives viualisables en courbes dans le graphe d’appels dynamique d’un programme.
 58 | Il calcule les métriques exclusives dans la phase de rapport.
 59 | XHProf supporte les fonctions recursives en détectant les cycles dans la pile d’appels dès la capture des données et en utilisant un nom unique pour l’invocation principale.</p>
 60 | 
 61 | <p>La nature légère d’XHProf, ses performances et ses possibilités de consolidations de données
 62 | en font un outil taillé pour les environnements de production [Voir <a
 63 | href="#production_notes">les notes</a> sur l’usage en production.]
 64 | 
 65 | <ul>
 66 | <hr>
 67 | 
 68 | <p>XHProfLive (qui ne fait pas partie de ce kit open source), par exemple, 
 69 | est un système de monitoring de performance utilsé chez Facebook et qui est bâti sur XHProf.
 70 | XHProfLive récupère en permanence les données de profilage en production en lançant XHProf sur un échantillon de pages
 71 | XHProfLive aggrège ensuite les données suivant des critères tels que le temps, type de pages, et peut aider à répondre à tout type de questions comme :
 72 | Quel est le profil de la pile d’appel pour une page spécifique ? Quel est le coût de la méthode "foo" dans toutes les pages, ou sur une page spécifique ? quelles fonctions ont régressé le plus depuis une heure, un jour pou un mois ? Quel est l’historique des tendances, des temps d’executions pour une page ou une fonction …
 73 | 
 74 | <hr>
 75 | </ul>
 76 | 
 77 | 
 78 | <p>Développé à l’origine par Facebook, XHProf est maintenant open source depuis mars 2009.</p>
 79 | 
 80 | 
 81 | </ul>
 82 | 
 83 | 
 84 | <li><a name="overview"><h2>Présentation</h2></a>
 85 | 
 86 | <p>XHProf offre:
 87 | 
 88 | <ul>
 89 | <li><b>Un rendu tabulaire</b> (<a href="sample-flat-view.jpg" >copie d’écran</a>)
 90 | 
 91 | <p>Un résumé des appels de fonctions avec des informations telles que le nombre d’appels,
 92 | inclusivement et exclusivement, les temps, la charge mémoire, et le temps processeur.
 93 | 
 94 | <p><li><b>Un rendu hiérarchique (Vue parent/enfant)</b>
 95 | (<a href="sample-parent-child-view.jpg" >copie d’écran</a>)
 96 | 
 97 | <p>Pour chaque fonction, il fournit le détail des appels et le temps par
 98 | parent (appelant) & enfant (appelé), tel que :
 99 | 
100 | <ul>
101 | 
102 | <li> quelle fonctions appelle quelle fonction précisement et combien de fois ?
103 | 
104 | <li> Quelles fonctions font un appel particulier ?
105 | 
106 | <li> Le temps total passé dans une fonction appelé par un parent bien précis.
107 | 
108 | </ul>
109 | 
110 | <p><li><b>Comparateur de rapports</b>
111 | 
112 | <p>Vous pouvez comparer les données de deux appels à XHProf pour des raisons diverses; 
113 | Pour voir ce qui cause une régression entre une version du code et une autre, 
114 | Pour évaluer l’impact sur les performances d’une évolution dans le code …
115 | 
116 | <p>Une comparaison de rapport prends deux runs en entrée et produit à la fois des informations différencielles au niveau de la fonction, mais aussi des informations hiérarchiques (séparation des différences par fonction parente/enfant) pour chaque fonction.
117 | 
118 | <p>La vue tabulaire (<a href="sample-diff-report-flat-view.jpg"
119 | >copie d’écran</a>) du rapport différentiel pointe les plus grosses améliorations et régressions.
120 | 
121 | <p>Cliquer sur un nom de fonction dans la bue tabulaire du rapport différentiel, mène à la vue hiérarchique 
122 | (ou vue parent/enfant) différentielle d’une fonction (<a href="sample-diff-report-parent-child-view.jpg"
123 | >copie d’écran</a>). On peut ainsi avoir une séparation des différences par fonctions parent/enfant.
124 | 
125 | <p><li><b>Callgraph View</b> (<a href="sample-callgraph-image.jpg"
126 | >copie d’écran</a>)
127 | 
128 | <p>Les données du rapport peuvent également être visualisées sous forme de graphique. 
129 | Cette vue permet de mettre en lumière les chemins crtiques du programme.
130 | 
131 | <p><li><b>Profilage mémoire</b>
132 | 
133 | <p>Le mode profilage mémoire d’XHProf aide à isoler les fonctions qui occupent trop de mémoire.
134 | 
135 | <p>On ne peut pas dire qu’XHProf trace exactement chaque opération 
136 | d’allocation/libération de mémoire, en effet il utilise un schéma simplistique;
137 | Il trace les hausses et les baisse de besoin en mémoire allouée à PHP à chaque entré ou sortie de fonction.
138 | Il trace aussi les hausses et baisses de pics mémoire alloués à chaque fonction PHP.
139 | 
140 | <li>XHProf trace les opération <code>include, include_once, require and
141 | require_once</code> comme si c’était des fonctions. Le nom du fichier inclus est utilisé pour nommer <a
142 | href="#include_funcs">"fausses" fonctions</a>.
143 | 
144 | 
145 | </ul>
146 | 
147 | <a name="Terminology"></a><h2>Terminologie</h2>
148 | <ol>
149 | 
150 | <a name="inclusive"></a><li><b>Temps inclusive (ou temps du sous-ensemble)</b>:
151 | Inclus le temps passé dans la fonction et celui passé dans les fonctions descendantes (filles).
152 | 
153 | <a name="exclusive"></a><li><b>Temps exclusive (ou temps "propre")</b>: Mesure le temps passé dans la fonction elle-même et n’inclus pas le temps passé dans les fonctions descendantes.
154 | 
155 | <li><b>Wall Time</b>: Temps passé ou temps ressenti.
156 | 
157 | <li><b>CPU Time</b>: Charge CPU sur les process utilisateur + charge CPU sur les process noyaux
158 | 
159 | </ol>
160 | <a name="Naming_convention_for_special_functions"></a><h2>Convention de nommage pour les fonctions spéciales</h2>
161 | 
162 | <ol>
163 | <p><li><code><b>main()</b></code>: Une fonction fictive qui est à la racine de la pile d’appel.
164 | 
165 | <a name="include_funcs"></a>
166 | <p><li><code><b>load::&lt;filename&gt;</b></code>
167 | et <code><b>run_init::&lt;filename&gt;</b></code>:
168 | 
169 | <p>XHProf trace les appels <code>include/require</code> comme des appels de fonction.
170 | 
171 | <p>Par exemple, une inclusion <b>include "lib/common.php";</b> va donner deux entrées pour XHProf :
172 | 
173 | <ul>
174 | 
175 | <li> <code><b>load::lib/common.php</b></code> - Cela représente le travail fait par l’interpréteur pour charger et compiler le fichier.
176 | [Note: Si vous utilisez un cache d’opcode PHP comme APC, alors la compilation intervient uniquement si le cahce est manquant dans APC.]
177 | 
178 | <li> <code><b>run_init::lib/common.php</b></code> - Cela répresente le code exécuté au niveau du fichier, soit le résultat de l’inclusion.
179 | 
180 | </ul>
181 | 
182 | <p><li><code><b>foo@&lt;n&gt;</b></code>: Implique un appel récursif de <code>foo()</code>, ou <code>&lt;n&gt;</code> représente le niveau de récursion.
183 | Cette récursion peut être directe comme <code>foo()</code> --&gt; <code>foo()</code>), ou indirecte comme </code>foo()</code> --&gt; <code>goo()</code> --&gt; foo().
184 | 
185 | </ol>
186 | 
187 | 
188 | <a name="Limitations"></a><h2>Limitations</h2>
189 | 
190 | <p>Un vrai profileur hiérarchique trace toute la pile d’appel pour chaque donnée., et est capables de répondre aux questions comme : Quel était le coût du 3e appel de foo(), ou quel était le coût de bar() quand il était appelé par a()-&gt;b()-&gt;bar()?
191 | 
192 | </p>
193 | 
194 | <p>XHProf garde une trace d’un seul niveau dans le contexte de l’appel et est seulement capable de répondre aux questions à propos 
195 | d’une fonction qui regarde un niveau en dessus ou en dessous. 
196 | Il appraît que dans la majorité des cas c’est bien suffisant.
197 | </p>
198 | 
199 | <p>Pour mieux comprendre, regaredez l’exemple suivant :
200 | </p>
201 | 
202 | <pre>
203 | Vous avez:
204 |  1 appel de a() --&gt; c()
205 |  1 appel de b() --&gt; c()
206 |  50 appels de c() --&gt; d()
207 | </pre>
208 | 
209 | <p>Quand XHProf peut vous dire que d() a été appelé par c() 50 fois, il ne peut pas vous dire
210 | combien d’appels dont dus à a() ou b(). 
211 | [On peut imaginer que c’est peut être 25 pour a() et 25 pour b(), mais ce n’est pas nécéssairement vrai.]
212 | </p>
213 | 
214 | <p>De toutes façons en pratique ce n’est pas vraiment une limitation.
215 | </p>
216 | 
217 | <li><a name="installation"><h2>Installer l’extension XHProf</h2></a>
218 | 
219 | <p> L’extension se trouve dans le sous-répertoire "extension/".
220 | 
221 | <ul><hr>
222 | 
223 | <p><b>Note:</b> Le portage pour Windows n’est pas encore implémenté. Nous avons testé <code>XHProf</code> sur <b>Linux/FreeBSD</b>.
224 | [NDT : Il existe un fork avec un portage Windows sur Github] 
225 | 
226 | <p>La version 0.9.2 et les précédentes sont aussi censées fonctionner sur <b>Mac
227 | OS</b>. [Cela a été testé sur Mac OS 10.5.]
228 | 
229 | <p><b>Note:</b> XHProf utilise les insctructions RDTSC (time stamp counter)
230 | pour implémenter un compteur de temps vraiment bas niveau. C’est pourquoi actuellement <code>xhprof</code> fonctionne uniquement sur une architecture <b>x86</b>.
231 | Aussi tant que les valeurs de RDTSC ne pourront pas être synchronisées entre plusieurs CPUs,
232 | <code>xhprof</code> n’en utilisera qu’un seul lors du profilage.
233 | 
234 | <p>Le timer XHProf bzasé sur RDTSC ne fonctionen pas parfaitement si la techno
235 | <b>SpeedStep</b> est activée. Cette technologie est disponible sur certains processeurs Intel.
236 | [Note: Les Macs ont typiquement cette fonctionnalité d’activée par défaut, il faut donc la désactiver pour utiliser XHProf.]
237 | 
238 | <hr></ul>
239 | 
240 | <p> Les étapes suivantes sont prévues pour un environnement Linux/Unix.
241 | 
242 | 
243 | <pre>
244 | % cd &lt;repertoire_source_xhprof&gt;/extension/
245 | % phpize
246 | % ./configure --with-php-config=&lt;chemin vers php-config&gt;
247 | % make
248 | % make install
249 | % make test
250 | </pre>
251 | 
252 | 
253 | <p><a name="ini_file"></a><b>php.ini file</b>: Vous pouvez mettre à jour votre fichier 
254 | php.ini file afin qu’il charge automatiquement votre extension en ajoutant le code suivant :
255 | 
256 | <pre>
257 | [xhprof]
258 | extension=xhprof.so
259 | ;
260 | ; répertoire utilisé par l’implémentation par défaut de l’interface iXHProfRuns
261 | ; (nommée, XHProfRuns_Default class) pour stocker les runs XHProf.
262 | ;
263 | xhprof.output_dir=&lt;repertoire_pour_stocker_les_runs_xhprof&gt;
264 | </pre>
265 | 
266 | 
267 | <li><a name="using_extension"><h2>Profiler avec XHProf</h2></a>
268 | 
269 | <p>Test de génération de donées brutes avec l’exemple simple d’un programme tel que :
270 | 
271 | <ul>
272 | <p><b>foo.php</b>
273 | <pre>
274 | &lt;?php
275 | 
276 | function bar($x) {
277 |   if ($x > 0) {
278 |     bar($x - 1);
279 |   }
280 | }
281 | 
282 | function foo() {
283 |   for ($idx = 0; $idx < 2; $idx++) {
284 |     bar($idx);
285 |     $x = strlen("abc");
286 |   }
287 | }
288 | 
289 | // début du profileur
290 | <b>xhprof_enable();</b>
291 | 
292 | // début du programme
293 | foo();
294 | 
295 | // attêt du profileur
296 | <b>$xhprof_data = xhprof_disable();</b>
297 | 
298 | // affichage des données de profilage brutes
299 | print_r($xhprof_data);
300 | </pre>
301 | </ul>
302 | 
303 | <p><b>Lancez ce programme :</b>
304 | 
305 | <pre>
306 | % php -dextension=xhprof.so foo.php
307 | </pre>
308 | 
309 | <p><b>Vous devez avoir un résultat tel que :</b>
310 | 
311 | <pre>
312 | Array
313 | (
314 |     [foo==>bar] => Array
315 |         (
316 |             [ct] => 2         # 2 appels de bar() depuis foo()
317 |             [wt] => 27        # temps inclusif dans bar() quand il est appelé par foo()
318 |         )
319 | 
320 |     [foo==>strlen] => Array
321 |         (
322 |             [ct] => 2
323 |             [wt] => 2
324 |         )
325 | 
326 |     [bar==>bar@1] => Array    # un appelrécursif à bar()
327 |         (
328 |             [ct] => 1
329 |             [wt] => 2
330 |         )
331 | 
332 |     [main()==>foo] => Array
333 |         (
334 |             [ct] => 1
335 |             [wt] => 74
336 |         )
337 | 
338 |     [main()==>xhprof_disable] => Array
339 |         (
340 |             [ct] => 1
341 |             [wt] => 0
342 |         )
343 | 
344 |     [main()] => Array         # fausse fonction représentant la racine
345 |         (
346 |             [ct] => 1
347 |             [wt] => 83
348 |         )
349 | 
350 | )
351 | </pre>
352 | 
353 | <p><b>Note:</b> Les données brutes contienent uniquement les métriques inclusives.
354 | Par exemple les données brutes du tableau de données temporelles represente les temps inclusifs en microsecondes.
355 | Les temps exclusifs sont calculés pour chaque fonction lors de la phase d’analyse et de rapport.
356 | 
357 | <p><b>Note:</b> Par défault suelemnt le nombre d’appel & et le temps passé sont profilés.
358 | Vous pouvez aussi profilerle temps CPU et/ou la charge mémoire. Remplacez,
359 | 
360 | <ul><pre>
361 | <b>xhprof_enable();</b>
362 | </pre></ul>
363 | dans le programme précédent avec, par exemple :
364 | <ul><pre>
365 | <b>xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY)</b>;
366 | </pre></ul>
367 | 
368 | <p><b>Vous aurez en sortie :</b>
369 | 
370 | <pre>
371 | Array
372 | (
373 |     [foo==>bar] => Array
374 |         (
375 |             [ct] => 2        # nombre d’appel à bar() depuis foo()
376 |             [wt] => 37       # tempas passé dans bar() quand appel de foo()
377 |             [cpu] => 0       # temps cpu time dans bar() quand appel de foo()
378 |             [mu] => 2208     # changement dans l’usage de la mémoire par PHP dans bar() quand appel de foo()
379 |             [pmu] => 0       # changement dans l’usage de pic mémoire par PHP pour bar() quand appel de foo()
380 |         )
381 | 
382 |     [foo==>strlen] => Array
383 |         (
384 |             [ct] => 2
385 |             [wt] => 3
386 |             [cpu] => 0
387 |             [mu] => 624
388 |             [pmu] => 0
389 |         )
390 | 
391 |     [bar==>bar@1] => Array
392 |         (
393 |             [ct] => 1
394 |             [wt] => 2
395 |             [cpu] => 0
396 |             [mu] => 856
397 |             [pmu] => 0
398 |         )
399 | 
400 |     [main()==>foo] => Array
401 |         (
402 |             [ct] => 1
403 |             [wt] => 104
404 |             [cpu] => 0
405 |             [mu] => 4168
406 |             [pmu] => 0
407 |         )
408 | 
409 |     [main()==>xhprof_disable] => Array
410 |         (
411 |             [ct] => 1
412 |             [wt] => 1
413 |             [cpu] => 0
414 |             [mu] => 344
415 |             [pmu] => 0
416 |         )
417 | 
418 |     [main()] => Array
419 |         (
420 |             [ct] => 1
421 |             [wt] => 139
422 |             [cpu] => 0
423 |             [mu] => 5936
424 |             [pmu] => 0
425 |         )
426 | 
427 | )
428 | </pre>
429 | 
430 | <p><b>Éviter les fonctions natives lors du profilage</b>
431 | 
432 | <p>Par défault les fonctions natives de PHP (comme <code>strlen</code>) sont profilées. 
433 | Si vous ne voulez pas les profiler (pour simplifier le résultat et la taille des données brutes générées), 
434 | Vous pouvez utiliser le drapeau <code><b>XHPROF_FLAGS_NO_BUILTINS</b></code> comme dans l’exemple ci-dessous :
435 | 
436 | <ul><pre>
437 | // ne pas profiler les fonctions natives
438 | <b>xhprof_enable(XHPROF_FLAGS_NO_BUILTINS)</b>;
439 | </pre></ul>
440 | 
441 | 
442 | <p><b>Ignorer des fonctions spécfiques lors du profilage (0.9.2 ou plus récent)</b>
443 | 
444 | <p>À partir de la version 0.9.2 d’XHProf, vous pouvez spécifier une liste de 
445 | fonctions à ignorer pendant le profilage. Cela vous permet de ne pas prendre en compte par exemple
446 | des fonctions utilisées pour des appels indirects comme <code>call_user_func</code> et <code>call_user_func_array</code>. 
447 | Ces fonctions intermédiaires compliquent inutilement la hirarchie des appels et rendent plus ardue l’interprétation des rapports en brouillant les relations parent/enfant.
448 | 
449 | <p>Pour spécifier cette liste de fonctions à ignorer durant le profilage, il suffit d’utiliser le second paramètre (optionnel) de <code>xhprof_enable</code>.
450 | Par exemple,
451 | 
452 | <pre>
453 | <ul><pre>
454 | <b>
455 | // temps passé en profilage; ignore les appels de call_user_func* pendant le profilage
456 | xhprof_enable(0,
457 |              array('ignored_functions' =>  array('call_user_func',
458 |                                                  'call_user_func_array')));
459 | </b>
460 | or,
461 | <b>
462 | // tempas pasé en profilage + profilage mémoire; ignore call_user_func* durant le profilage
463 | xhprof_enable(XHPROF_FLAGS_MEMORY,
464 |               array('ignored_functions' =>  array('call_user_func',
465 |                                                   'call_user_func_array')));
466 | </b>
467 | </pre></ul>
468 | 
469 | 
470 | </li>
471 | 
472 | <li><a name="ui_setup"><h2>Définir un environnement graphique pour XHProf</h2></a>
473 | 
474 | 
475 | <ol>
476 | 
477 | <li><b>Structure de la source PHP</b>
478 | <p>l’interface graphique d’XHProf est implémentée en PHP. Le code est divisé en deux sous-répertoires, 
479 | <code>xhprof_html/</code> and <code>xhprof_lib/</code>.
480 | 
481 | <p>Le répertoire <code>xhprof_html</code> contient les 3 pages PHP principales.
482 | 
483 | <ul>
484 | <li><code>index.php</code>: Pour visualiser un run ou un différentiel entre deux runs.
485 | <li><code>callgraph.php</code>: Pour visualiser sous la forme de graphique avec un rendu en image.
486 | <li><code>typeahead.php</code>: Utilisé implicitement pour les fonctions de gestion de pile sur un rapport XHProf.
487 | </ul>
488 | 
489 | <p>Le répertoire <code>xhprof_lib</code> contient le code pour l’analyse et l’affichage. 
490 | (calcul sur les informations de profilage, calcul des différentiels, aggrégation de données, etc.).
491 | 
492 | <li><p><b>Configuration du server web : </b> Vous devez vous assurer que le répertoire 
493 | <code>xhprof_html/</code> est accessible depuis le serveur web, et qu’il est configuré pour éxécuter des scripts PHP.
494 | 
495 | <li><p><b>Gérer les runs XHProf</b>
496 | 
497 | <p>Les clients web ont une certaine souplesse dans la manière de sauvegarder les données brutes fournies par XHProf. 
498 | XHProf expose une interface utilisateur nommée iXHProfRuns (voir xhprof_lib/utils/xhprof_runs.php) que les clients peuvent implémenter. 
499 | Cela permet aux clients de préciser comment afficher les donées des runs.
500 | 
501 | <p>L’interface utilisateur d’XHProf fournit une implementation par défaut nommée, 
502 | "XHProfRuns_Default" (aussi dans xhprof_lib/utils/xhprof_runs.php).
503 | L’implementation par d"faut stocke les runs dans le répertoire définit par le paramètre INI :  
504 | <a href="#ini_file"><b>xhprof.output_dir</b></a>.
505 | 
506 | <p>Un run XHProf doit être définit de manière unique par un espace de nom et un identifiant de run.
507 | 
508 | <p><b>a) Sauver les données XHProf de façon persistente</b> :
509 | 
510 | <p>Soit si vous utilisez l’interface par défaut, 
511 | <code><b>XHProfRuns_Default</b></code> qui implémente 
512 | <code><b>iXHProfRuns</b></code>, Un run XHProf sauvegardé ressemble au code suivant :
513 | 
514 | 
515 | <pre>
516 | // début du profilage
517 | xhprof_enable();
518 | 
519 | // lancement du programme
520 | ...
521 | 
522 | // fin du profilage
523 | $xhprof_data = xhprof_disable();
524 | 
525 | //
526 | // Sauvegarde du run XHProf
527 | // en utilisant l’implementation par défaut de iXHProfRuns.
528 | //
529 | include_once $XHPROF_ROOT . "/xhprof_lib/utils/xhprof_lib.php";
530 | include_once $XHPROF_ROOT . "/xhprof_lib/utils/xhprof_runs.php";
531 | 
532 | $xhprof_runs = new <b>XHProfRuns_Default()</b>;
533 | 
534 | // sauvegarde du run avec l’espace de nom "xhprof_foo".
535 | //
536 | // **NOTE**:
537 | // par défault save_run() va automatiquement générer un identifiant de run
538 | // unique. [Vous pouvez surcharger cette donnée en passant l’identifiant en paramètre optionnel 
539 | // à la méthode save_run().]
540 | //
541 | <b>$run_id = $xhprof_runs->save_run($xhprof_data, "xhprof_foo");</b>
542 | 
543 | echo "---------------\n".
544 |      "En partant du principe que vous avez parametré l’interface utilisateur http \n".
545 |      "XHProf, vous pouvez visualiser les runs avec l’adresse : \n".
546 |      "http://&lt;adresse-interface-utilisateur-xhprof&gt;/index.php?run=$run_id&source=xhprof_foo\n".
547 |      "---------------\n";
548 | 
549 | </pre>
550 | 
551 | <p>La suite permet de sauvegarder le run sous forme d’un fichier dans le répertoire spécifié
552 | par le paramètre ini <code><b>xhprof.output_dir</b></code>. Le nom du fichier doit être de la forme
553 | <b><code>49bafaa3a3f66.xhprof_foo</code></b>; Les deux parties du nom sont formées par l’identifiant du run 
554 | ("49bafaa3a3f66") et l’espace de nom ("xhprof_foo"). [Si vous souhaitez créer un identifiant de run vous-même 
555 | (comme une sequence de base de données, ou un timestamp), vous pouvez explicitementpasser l’identifiant 
556 | du run à la méthode <code>save_run</code>.
557 | 
558 | <p><b>b) En utilisant votre propre implementation d’iXHProfRuns</b>
559 | 
560 | <p> Si vous décidez de stocker différement les runs XHProf 
561 | (soit dans un format compressé, dans une base de données,
562 | etc.), vous aurez besoin d’implémenter une classe qui implémente l’interface
563 | iXHProfRuns().
564 | 
565 | <p> Vous devrez également modifier les 3 pages PHP d’entrée (index.php,
566 | callgraph.php, typeahead.php) dans le répertoire "xhprof_html/" pour utiliser la 
567 | nouvelle interface au lieu de celle par défaut (<code>XHProfRuns_Default</code>),
568 | changez cette ligne dans les 3 fichier.
569 | 
570 | <pre>
571 | $xhprof_runs_impl = new XHProfRuns_Default();
572 | </pre>
573 | 
574 | <p>Vous aurez aussi besoin d’inclure le fichier qui implémente votre classe dans les fichiers cités.
575 | 
576 | <li><p><b>Acceéder aux runs depuis l’interface utilisateur</b>
577 | 
578 | <p><b>a) Voir un rapport simple</b>
579 | 
580 | <p>Pour voir un rapport avec l’identifiant &lt;run_id&gt; et l’espace de nom
581 | &lt;namespace&gt; utilisez une url de la forme :
582 | 
583 | <p><code>
584 | http://&lt;adresse-interface-utilisateur-xhprof&gt;/index.php?run=&lt;run_id&gt;&source=&lt;namespace&gt;
585 | </code>
586 | 
587 | <p>Par example,
588 | <p><code>
589 | http://&lt;adresse-interface-utilisateur-xhprof&gt;/index.php?run=49bafaa3a3f66&source=xhprof_foo
590 | </code>
591 | 
592 | <p><b>b) Voir un rapport différentiel</b>
593 | 
594 | <p>Pour voir un rapport avec les identifiants &lt;run_id1&gt; et
595 | &lt;run_id2&gt; et l’espace de nom &lt;namespace&gt; utilisez une url de la forme :
596 | 
597 | <p><code>
598 | http://&lt;adresse-interface-utilisateur-xhprof&gt;/index.php?<b>run1=&lt;run_id1&gt;&run2=&lt;run_id2&gt;</b>&source=&lt;namespace&gt;
599 | </code>
600 | 
601 | <p><b>c) Voir un rapport d’aggrégation</b>
602 | 
603 | <p>Vous pouvez aussi spécifier un ensemble de runspour lesquels vous souhaitez un rapport d’aggrégation.
604 | 
605 | <p>Si vous avez trois runs XHProf avec les identifiants 1, 2 & 3 pour l’espace de noms
606 | "benchmark".  Pour voir l’aggrégation de ces trois runs :
607 | 
608 | <ul><p><code>
609 | http://&lt;adresse-interface-utilisateur-xhprof&gt;/index.php?<b>run=1,2,3</b>&source=benchmark
610 | </code></p></ul>
611 | 
612 | <p><b>Aggrégations pondérées</b>: En supposant que les trois runs
613 | correspondent à trois types de programmes p1.php, p2.php and p3.php 
614 | qui occupent chacun respectivement 20%, 30% et 50%. Pour voir un rapport d’aggrégation
615 | pondéré par les poids des runs :
616 | 
617 | <ul><p><code>
618 | http://&lt;adresse-interface-utilisateur-xhprof&gt;/index.php?<b>run=1,2,3&wts=20,30,50</b>&source=benchmark
619 | </code></p></ul>
620 | 
621 | </ol>
622 | 
623 | <li><a name="production_notes"><h2>Notes sur l’utilisation d’XHProf en production</h2></a>
624 | 
625 | <p>Quelques observations qui peuvent faire varier votre expérience :
626 | 
627 | <ul>
628 | 
629 | <li>Le timer CPU (getrusage) sur Linux peut avoir des dépassements de capacité. Il a également un rendu granuleux 
630 | (Une précision à la milliseconde plutôt qu’à la microseconde) pour être efficace au niveau des méthodes. 
631 | En conséquence, les valeurs rapportées en utilisant le mode XHPROF_FLAGS_CPU on tendance à être plus élevés.
632 | 
633 | <p>Nous recommandons d’utiliser le mode de profilage "temps passé" + "memoire" en production. 
634 | [Note: Le surplus de temps passé par le mode de profilage mémoire est non significatif.]
635 | 
636 | <p><ul><pre><b>
637 |   // profilage du temps passé (par défault) + profilage mémoire
638 |   xhprof_enable(XHPROF_FLAGS_MEMORY);
639 | </b></pre>
640 | </ul></p>
641 | 
642 | 
643 | <li>Profiler une plage aléatoire de pages/requêtes est efficace pour récupérer des données représentatives 
644 | de votre environnement de production.
645 | 
646 | <p>Pour profiler 1/10000 de vos requêtes, définissez le début du profilage avec un code dans l’esprit de celui-ci :
647 | 
648 | <p><ul><pre><code>
649 |  if (mt_rand(1, 10000) == 1) {
650 |    xhprof_enable(XHPROF_FLAGS_MEMORY);
651 |    $xhprof_on = true;
652 |  }
653 | </code></pre></ul></p>
654 | 
655 | <p>À la fin de la requête (ou dans une fonction de finalisation de la requête), vous pouvez faire quelque chose comme :
656 | 
657 | <p><ul><pre><code>
658 |  if ($xhprof_on) {
659 |    // fin du profilage
660 |    $xhprof_data = xhprof_disable();
661 | 
662 |    // sauvegarde $xhprof_data quelquepart (base de données centralisée …)
663 |    ...
664 |  }
665 | </code></pre></ul></p>
666 | 
667 | <p> Vous pouvez alors récupérer et aggréger ces profilages par horaire 
668 | (par exemple 5 minutes, par jour, par jour …), par page ou type de requête, ou n’importe quel 
669 | paramètre utilisé par <a href="#xhprof_aggregate_runs"><code><b>xhprof_aggregate_runs()</b></code></a>.
670 | 
671 | </ul>
672 | 
673 | <li><a name="sampling_mode"><h2>Mode d’échantillonage léger</h2></a>
674 | 
675 | <p>L’extension XHProf propose aussi un <b>mode très léger d’échantillonage</b>. 
676 | L’intervalle est de 0,1 seconde. Les échantillons enregistrent l’ensemble des données.
677 | Ce mode peut être très utile pour avoir un impact le plus négligeable possible, et permettre 
678 | Le mode sample peut être utile si vous désirez un moyen avec peu de dépassement de faire de la surveillance de performances et des diagnostics.
679 | 
680 | <p>Les très pertinentes fonctions utilisées par l’extension pour utiliser le mode 
681 | d’échantillonage sont <code><b>xhprof_sample_enable()</b></code> et <code><b>xhprof_sample_disable()</b></code>.
682 | 
683 | <p>[<b>TBD</b>: Documentation plus détaillée pour le mode d’échantillonage.]
684 | 
685 | <li><a name="misc"><h2>Fonctionnalités supplémentaires</h2></a></li>
686 | 
687 | <p>Le fichier <code><b>XHProf_lib/utils/xhprof_lib.php</b></code> contient
688 | des librairies de fonctions additionellesqui peuvent être utilisées pour manipuler
689 | et aggréger les runs XHProf.
690 | 
691 | <p>Par exemple:
692 | 
693 | <ul>
694 | 
695 | <a name="xhprof_aggregate_runs"></a>
696 | <p><li><code><b>xhprof_aggregate_runs()</b></code>:
697 | peut être utilisé pour aggréger de multiples runs XHProf runs dans un seul run. 
698 | Cela peut être très utile pour fabriquer un outil de monitoring utilisant XHProf et à l’échelle voulue.
699 | [Par exemple, vous pouvez mixer des runs XHProf issus périodiquement 
700 | d’échantillonage de la production pour générer des rapport journalier.]
701 | 
702 | <p><li><code><b>xhprof_prune_run()</b></code>: Aggréger une grande quantité de runs
703 | (particulièrement si ils correspondent à des zones différentes du programme) peut créer un rendu 
704 | graphique beaucoup trop gros. Vous pouvez donc utiliser la fonction <code>xhprof_prune_run</code> 
705 | élaguer les données à afficher. En supprimant des branches qui compte pour une partie négligeable du temps passé.
706 | 
707 | </ul>
708 | 
709 | <ol>
710 | 
711 | </ol>
712 | 
713 | <li><a name="dependencies"><h2>Dependances</h2></a></li>
714 | 
715 | <ul>
716 | <li><b>JQuery Javascript</b>: Pour les bulles d’aides et les noms de fonctions de pile, 
717 | nous utilisons la librairie Javascript, JQuery. JQuery est disponible sous les licences MIT et GPL
718 | (http://docs.jquery.com/Licensing). Ce code JQuery, utilisé par XHProf, se trouve dans le 
719 | sous répertoire <code>xhprof_html/jquery</code>.
720 | 
721 | <li><b>dot (utilitaire de génération d’image):</b> Le fonctionnalité de rendu graphique
722 | ([View Callgraph]) est présente grâce à la présence de Graphviz "dot" dans votre path. 
723 | "dot" est un utilitaire de dessin et de gén"ration d’image.
724 | 
725 | </ul>
726 | <li><a name="credits"><h2>Remerciements</h2></a>
727 | 
728 | <p>Le rendu HTML et l’interface de navigation pour consulter les résultat du profilage sont inspirés par un outil similaire
729 | qui existe pour les procédures stockées PL/SQL d’Oracle. Mais c’est là que la comparaison s’arrête; 
730 | Le fonctionnement interne du profileur étant assez différent
731 | 
732 | [NDT : Merci à Rudy Rigot (@rudyrigot) pour sa relecture attentive ]
733 | </li>
734 | 
735 | </ol>
736 | 
737 | </body>
738 | </html>
739 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/docs/index.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 | <title>
  3 | XHProf Documentation (Draft)
  4 | </title>
  5 | <body>
  6 | <h3>XHProf Documentation (Draft)</h3>
  7 | 
  8 | <b>Contents</b>
  9 | <ol>
 10 | <li><a href="#introduction">Introduction</a></li>
 11 | 
 12 | <li><a href="#overview">XHProf Overview</a></li>
 13 | 
 14 | <li><a href="#installation">Installing the XHProf extension</a></li>
 15 | 
 16 | <li><a href="#using_extension">Profiling using XHProf</a></li>
 17 | 
 18 | <li><a href="#ui_setup">Setting up the XHProf UI</a></li>
 19 | 
 20 | <li><a href="#production_notes">Notes on using XHProf in production</a></li>
 21 | 
 22 | <li><a href="#sampling_mode">Lightweight Sampling Mode</a>
 23 | 
 24 | <li><a href="#misc">Additional features</a></li>
 25 | 
 26 | <li><a href="#dependencies">Dependencies</a></li>
 27 | 
 28 | <li><a href="#credits">Acknowledgements</a></li>
 29 | </ol>
 30 | 
 31 | <ol>
 32 | <li><a name="introduction"><h2>Introduction</h2></a>
 33 | 
 34 | <p>XHProf is a hierarchical profiler for PHP.  It reports
 35 | function-level call counts and <a href="#inclusive">inclusive</a> and
 36 | <a href="#exclusive">exclusive</a> metrics such as wall (elapsed)
 37 | time, CPU time and memory usage. A function's profile can be broken
 38 | down by callers or callees. The raw data collection component is
 39 | implemented in C as a PHP Zend extension called
 40 | <code><b>xhprof</b></code>. XHProf has a simple HTML based user
 41 | interface (written in PHP). The browser based UI for viewing profiler
 42 | results makes it easy to view results or to share results with peers.
 43 | A callgraph image view is also supported.
 44 | 
 45 | <p>XHProf reports can often be helpful in understanding the structure
 46 | of the code being executed. The hierarchical nature of the reports can
 47 | be used to determine, for example, what chain of calls led to a
 48 | particular function getting called.
 49 | 
 50 | <p>XHProf supports ability to compare two runs (a.k.a. "diff" reports)
 51 | or aggregate data from multiple runs. Diff and aggregate reports, much
 52 | like single run reports, offer "flat" as well as "hierarchical" views
 53 | of the profile.
 54 | 
 55 | <p>XHProf is a light-weight instrumentation based profiler. During the
 56 | data collection phase, it keeps track of call counts and inclusive
 57 | metrics for arcs in the dynamic callgraph of a program. It computes
 58 | exclusive metrics in the reporting/post processing phase. XHProf
 59 | handles recursive functions by detecting cycles in the callgraph at
 60 | data collection time itself and avoiding the cycles by giving unique
 61 | depth qualified names for the recursive invocations.
 62 | </p>
 63 | 
 64 | <p>XHProf's light-weight nature and aggregation capabilities make it
 65 | well suited for collecting "function-level" performance statistics
 66 | from production environments. [See <a
 67 | href="#production_notes">additional notes</a> for use in production.]
 68 | 
 69 | <ul>
 70 | <hr>
 71 | 
 72 | <p>XHProfLive (not part of the open source kit), for example, is a
 73 | system-wide performance monitoring system in use at Facebook that is
 74 | built on top of XHProf.  XHProfLive continually gathers function-level
 75 | profiler data from production tier by running a sample of page
 76 | requests under XHProf. XHProfLive then aggregates the profile data
 77 | corresponding to individual requests by various dimensions such as
 78 | time, page type, and can help answer a variety of questions such as:
 79 | What is the function-level profile for a specific page? How expensive
 80 | is function "foo" across all pages, or on a specific page? What
 81 | functions regressed most in the last hour/day/week? What is the
 82 | historical trend for execution time of a page/function? and so on.
 83 | 
 84 | <hr>
 85 | </ul>
 86 | 
 87 | 
 88 | <p>Originally developed at Facebook, XHProf was open sourced in Mar, 2009.</p>
 89 | 
 90 | 
 91 | </ul>
 92 | 
 93 | 
 94 | <li><a name="overview"><h2>XHProf Overview</h2></a>
 95 | 
 96 | <p>XHProf provides:
 97 | 
 98 | <ul>
 99 | <li><b>Flat profile</b> (<a href="sample-flat-view.jpg" >screenshot</a>)
100 | 
101 | <p>Function-level summary information such as number of calls,
102 | inclusive/exclusive wall time, memory usage, and CPU time.
103 | 
104 | <p><li><b>Hierarchical profile (Parent/Child View)</b>
105 | (<a href="sample-parent-child-view.jpg" >screenshot</a>)
106 | 
107 | <p>For each function, it provides a breakdown of calls and times per
108 | parent (caller) & child (callee), such as:
109 | 
110 | <ul>
111 | 
112 | <li> what functions call a particular function and how many times?
113 | 
114 | <li> what functions does a particular function call?
115 | 
116 | <li> The total time spent under a function when called from a particular parent.
117 | 
118 | </ul>
119 | 
120 | <p><li><b>Diff Reports</b>
121 | 
122 | <p>You may want to compare data from two XHProf runs for various
123 | reasons-- to figure out what's causing a regression between one
124 | version of the code base to another, to evaluate the performance
125 | improvement of a code change you are making, and so on.
126 | 
127 | <p>A diff report takes two runs as input and provides both flat
128 | function-level diff information, and hierarchical information
129 | (breakdown of diff by parent/children functions) for each function.
130 | 
131 | <p>The "flat" view (<a href="sample-diff-report-flat-view.jpg"
132 | >sample screenshot</a>) in the diff report points out the top
133 | regressions & improvements.
134 | 
135 | <p>Clicking on functions in the "flat" view of the diff report, leads
136 | to the "hierarchical" (or parent/child) diff view of a function (<a href="sample-diff-report-parent-child-view.jpg"
137 | >sample screenshot</a>). We can get a
138 | breakdown of the diff by parent/children functions.
139 | 
140 | 
141 | <p><li><b>Callgraph View</b> (<a href="sample-callgraph-image.jpg"
142 | >sample screenshot</a>)
143 | 
144 | <p>The profile data can also be viewed as a callgraph. The callgraph
145 | view highlights the critical path of the program.
146 | 
147 | 
148 | <p><li><b>Memory Profile</b>
149 | 
150 | <p>XHProf's memory profile mode helps track functions that
151 | allocate lots of memory.
152 | 
153 | <p>It is worth clarifying that that XHProf doesn't strictly track each
154 | allocation/free operation.  Rather it uses a more simplistic
155 | scheme. It tracks the increase/decrease in the amount of memory
156 | allocated to PHP between each function's entry and exit. It also
157 | tracks increase/decrease in the amount of <b>peak</b> memory allocated to
158 | PHP for each function.
159 | 
160 | <li>XHProf tracks <code>include, include_once, require and
161 | require_once</code> operations as if they were functions. The name of
162 | the file being included is used to generate the name for these <a
163 | href="#include_funcs">"fake" functions</a>.
164 | 
165 | 
166 | </ul>
167 | 
168 | <a name="Terminology"></a><h2>Terminology</h2>
169 | <ol>
170 | 
171 | <a name="inclusive"></a><li><b>Inclusive Time (or Subtree Time)</b>:
172 | Includes time spent in the function as well as in descendant functions
173 | called from a given function.
174 | 
175 | <a name="exclusive"></a><li><b>Exclusive Time/Self Time</b>: Measures
176 | time spent in the function itself. Does not include time in descendant
177 | functions.
178 | 
179 | <li><b>Wall Time</b>: a.k.a. Elapsed time or wall clock time.
180 | 
181 | <li><b>CPU Time</b>: CPU time in user space + CPU time in kernel space
182 | 
183 | </ol>
184 | <a name="Naming_convention_for_special_functions"></a><h2>Naming convention for special functions</h2>
185 | 
186 | <ol>
187 | <p><li><code><b>main()</b></code>: a fictitious function that is at the root of the call graph.
188 | 
189 | <a name="include_funcs"></a>
190 | <p><li><code><b>load::&lt;filename&gt;</b></code>
191 | and <code><b>run_init::&lt;filename&gt;</b></code>:
192 | 
193 | <p>XHProf tracks PHP <code>include/require</code> operations as
194 | function calls.
195 | 
196 | <p>For example, an <b>include "lib/common.php";</b> operation will
197 | result in two XHProf function entries:
198 | 
199 | <ul>
200 | 
201 | <li> <code><b>load::lib/common.php</b></code> - This represents the work done by the
202 | interpreter to compile/load the file. [Note: If you are using a PHP
203 | opcode cache like APC, then the compile only happens on a cache miss
204 | in APC.]
205 | 
206 | <li> <code><b>run_init::lib/common.php</b></code> - This represents
207 | initialization code executed at the file scope as a result of the
208 | include operation.
209 | 
210 | </ul>
211 | 
212 | <p><li><code><b>foo@&lt;n&gt;</b></code>: Implies that this is a
213 | recursive invocation of <code>foo()</code>, where <code>&lt;n&gt;</code> represents
214 | the recursion depth. The recursion may be direct (such as due to
215 | <code>foo()</code> --&gt; <code>foo()</code>), or indirect (such as
216 | due to </code>foo()</code> --&gt; <code>goo()</code> --&gt; foo()).
217 | 
218 | </ol>
219 | 
220 | 
221 | <a name="Limitations"></a><h2>Limitations</h2>
222 | 
223 | <p>True hierarchical profilers keep track of a full call stack at
224 | every data gathering point, and are later able to answer questions
225 | like: what was the cost of the 3rd invokation of foo()? or what was
226 | the cost of bar() when the call stack looked like
227 | a()-&gt;b()-&gt;bar()?
228 | 
229 | </p>
230 | 
231 | <p>XHProf keeps track of only 1-level of calling context and is
232 | therefore only able to answer questions about a function looking
233 | either 1-level up or 1-level down. It turns out that in practice this
234 | is sufficient for most use cases.
235 | </p>
236 | 
237 | <p>To make this more concrete, take for instance the following
238 | example.
239 | </p>
240 | 
241 | <pre>
242 | Say you have:
243 |  1 call from a() --&gt; c()
244 |  1 call from b() --&gt; c()
245 |  50 calls from c() --&gt; d()
246 | </pre>
247 | 
248 | <p>While XHProf can tell you that d() was called from c() 50 times, it
249 | cannot tell you how many of those calls were triggered due to a()
250 | vs. b(). [We could speculate that perhaps 25 were due to a() and 25
251 | due to b(), but that's not necessarily true.]
252 | </p>
253 | 
254 | <p>In practice however, this isn't a very big limitation.
255 | </p>
256 | 
257 | <li><a name="installation"><h2>Installing the XHProf Extension</h2></a>
258 | 
259 | <p> The extension lives in the "extension/" sub-directory.
260 | 
261 | <ul><hr>
262 | 
263 | <p><b>Note:</b> A windows port hasn't been implemented yet. We have
264 | tested <code>xhprof</code> on <b>Linux/FreeBSD</b> so far. 
265 | 
266 | <p>Version 0.9.2 and above of XHProf is also expected to work on <b>Mac
267 | OS</b>. [We have tested on Mac OS 10.5.]
268 | 
269 | <p><b>Note:</b> XHProf uses the RDTSC instruction (time stamp counter)
270 | to implement a really low overhead timer for elapsed time. So at the
271 | moment <code>xhprof</code> only works on <b>x86</b> architecture.
272 | Also, since RDTSC values may not be synchronized across CPUs,
273 | <code>xhprof</code> binds the program to a single CPU during the
274 | profiling period.
275 | 
276 | <p>XHProf's RDTSC based timer functionality doesn't work correctly if
277 | <b>SpeedStep</b> technology is turned on. This technology is available on
278 | some Intel processors. [Note: Mac desktops and laptops typically have
279 | SpeedStep turned on by default. To use XHProf, you'll need to disable
280 | SpeedStep.]
281 | 
282 | <hr></ul>
283 | 
284 | <p> The steps
285 | below should work for Linux/Unix environments.
286 | 
287 | 
288 | <pre>
289 | % cd &lt;xhprof_source_directory&gt;/extension/
290 | % phpize
291 | % ./configure --with-php-config=&lt;path to php-config&gt;
292 | % make
293 | % make install
294 | % make test
295 | </pre>
296 | 
297 | 
298 | <p><a name="ini_file"></a><b>php.ini file</b>: You can update your
299 | php.ini file to automatically load your extension.  Add the following
300 | to your php.ini file.
301 | 
302 | <pre>
303 | [xhprof]
304 | extension=xhprof.so
305 | ;
306 | ; directory used by default implementation of the iXHProfRuns
307 | ; interface (namely, the XHProfRuns_Default class) for storing
308 | ; XHProf runs.
309 | ;
310 | xhprof.output_dir=&lt;directory_for_storing_xhprof_runs&gt;
311 | </pre>
312 | 
313 | 
314 | <li><a name="using_extension"><h2>Profiling using XHProf</h2></a>
315 | 
316 | <p>Test generating raw profiler data using a sample test program like:
317 | 
318 | <ul>
319 | <p><b>foo.php</b>
320 | <pre>
321 | &lt;?php
322 | 
323 | function bar($x) {
324 |   if ($x > 0) {
325 |     bar($x - 1);
326 |   }
327 | }
328 | 
329 | function foo() {
330 |   for ($idx = 0; $idx < 2; $idx++) {
331 |     bar($idx);
332 |     $x = strlen("abc");
333 |   }
334 | }
335 | 
336 | // start profiling
337 | <b>xhprof_enable();</b>
338 | 
339 | // run program
340 | foo();
341 | 
342 | // stop profiler
343 | <b>$xhprof_data = xhprof_disable();</b>
344 | 
345 | // display raw xhprof data for the profiler run
346 | print_r($xhprof_data);
347 | </pre>
348 | </ul>
349 | 
350 | <p><b>Run the above test program:</b>
351 | 
352 | <pre>
353 | % php -dextension=xhprof.so foo.php
354 | </pre>
355 | 
356 | <p><b>You should get an output like:</b>
357 | 
358 | <pre>
359 | Array
360 | (
361 |     [foo==>bar] => Array
362 |         (
363 |             [ct] => 2         # 2 calls to bar() from foo()
364 |             [wt] => 27        # inclusive time in bar() when called from foo()
365 |         )
366 | 
367 |     [foo==>strlen] => Array
368 |         (
369 |             [ct] => 2
370 |             [wt] => 2
371 |         )
372 | 
373 |     [bar==>bar@1] => Array    # a recursive call to bar()
374 |         (
375 |             [ct] => 1
376 |             [wt] => 2
377 |         )
378 | 
379 |     [main()==>foo] => Array
380 |         (
381 |             [ct] => 1
382 |             [wt] => 74
383 |         )
384 | 
385 |     [main()==>xhprof_disable] => Array
386 |         (
387 |             [ct] => 1
388 |             [wt] => 0
389 |         )
390 | 
391 |     [main()] => Array         # fake symbol representing root
392 |         (
393 |             [ct] => 1
394 |             [wt] => 83
395 |         )
396 | 
397 | )
398 | </pre>
399 | 
400 | <p><b>Note:</b> The raw data only contains "inclusive" metrics. For
401 | example, the wall time metric in the raw data represents inclusive
402 | time in microsecs.  Exclusive times for any function are computed
403 | during the analysis/reporting phase.
404 | 
405 | <p><b>Note:</b> By default only call counts & elapsed time is profiled.
406 | You can optionally also profile CPU time and/or memory usage. Replace,
407 | 
408 | <ul><pre>
409 | <b>xhprof_enable();</b>
410 | </pre></ul>
411 | in the above program with, for example:
412 | <ul><pre>
413 | <b>xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY)</b>;
414 | </pre></ul>
415 | 
416 | <p><b>You should now get an output like:</b>
417 | 
418 | <pre>
419 | Array
420 | (
421 |     [foo==>bar] => Array
422 |         (
423 |             [ct] => 2        # number of calls to bar() from foo()
424 |             [wt] => 37       # time in bar() when called from foo()
425 |             [cpu] => 0       # cpu time in bar() when called from foo()
426 |             [mu] => 2208     # change in PHP memory usage in bar() when called from foo()
427 |             [pmu] => 0       # change in PHP peak memory usage in bar() when called from foo()
428 |         )
429 | 
430 |     [foo==>strlen] => Array
431 |         (
432 |             [ct] => 2
433 |             [wt] => 3
434 |             [cpu] => 0
435 |             [mu] => 624
436 |             [pmu] => 0
437 |         )
438 | 
439 |     [bar==>bar@1] => Array
440 |         (
441 |             [ct] => 1
442 |             [wt] => 2
443 |             [cpu] => 0
444 |             [mu] => 856
445 |             [pmu] => 0
446 |         )
447 | 
448 |     [main()==>foo] => Array
449 |         (
450 |             [ct] => 1
451 |             [wt] => 104
452 |             [cpu] => 0
453 |             [mu] => 4168
454 |             [pmu] => 0
455 |         )
456 | 
457 |     [main()==>xhprof_disable] => Array
458 |         (
459 |             [ct] => 1
460 |             [wt] => 1
461 |             [cpu] => 0
462 |             [mu] => 344
463 |             [pmu] => 0
464 |         )
465 | 
466 |     [main()] => Array
467 |         (
468 |             [ct] => 1
469 |             [wt] => 139
470 |             [cpu] => 0
471 |             [mu] => 5936
472 |             [pmu] => 0
473 |         )
474 | 
475 | )
476 | </pre>
477 | 
478 | <p><b>Skipping builtin functions during profiling</b>
479 | 
480 | <p>By default PHP builtin functions (such as <code>strlen</code>) are
481 | profiled. If you do not want to profile builtin functions (to either
482 | reduce the overhead of profiling further or size of generated raw
483 | data), you can use the <code><b>XHPROF_FLAGS_NO_BUILTINS</b></code>
484 | flag as in for example:
485 | 
486 | <ul><pre>
487 | // do not profile builtin functions
488 | <b>xhprof_enable(XHPROF_FLAGS_NO_BUILTINS)</b>;
489 | </pre></ul>
490 | 
491 | 
492 | <p><b>Ignoring specific functions during profiling (0.9.2 or higher)</b>
493 | 
494 | <p>Starting with release 0.9.2 of xhprof, you can tell XHProf to
495 | ignore a specified list of functions during profiling. This allows you
496 | to ignore, for example, functions used for indirect function calls
497 | such as <code>call_user_func</code> and
498 | <code>call_user_func_array</code>. These intermediate functions
499 | unnecessarily complicate the call hierarchy and make the XHProf
500 | reports harder to interpret since they muddle the parent-child
501 | relationship for functions called indirectly.
502 | 
503 | <p> To specify the list of functions to be ignored during profiling
504 | use the 2nd (optional) argument to <code>xhprof_enable</code>.
505 | For example,
506 | 
507 | <pre>
508 | <ul><pre>
509 | <b>
510 | // elapsed time profiling; ignore call_user_func* during profiling
511 | xhprof_enable(0,
512 |              array('ignored_functions' =>  array('call_user_func',
513 |                                                  'call_user_func_array')));
514 | </b>
515 | or,
516 | <b>
517 | // elapsed time + memory profiling; ignore call_user_func* during profiling
518 | xhprof_enable(XHPROF_FLAGS_MEMORY,
519 |               array('ignored_functions' =>  array('call_user_func',
520 |                                                   'call_user_func_array')));
521 | </b>
522 | </pre></ul>
523 | 
524 | 
525 | </li>
526 | 
527 | <li><a name="ui_setup"><h2>Setting up XHProf UI</h2></a>
528 | 
529 | 
530 | <ol>
531 | 
532 | <li><b>PHP source structure</b>
533 | <p>The XHProf UI is implemented in PHP. The code resides in two
534 | subdirectories, <code>xhprof_html/</code> and <code>xhprof_lib/</code>.
535 | 
536 | <p>The <code>xhprof_html</code> directory contains the 3 top-level PHP pages.
537 | 
538 | <ul>
539 | <li><code>index.php</code>: For viewing a single run or diff report.
540 | <li><code>callgraph.php</code>: For viewing a callgraph of a XHProf run as an image.
541 | <li><code>typeahead.php</code>: Used implicitly for the function typeahead form
542 | on a XHProf report.
543 | </ul>
544 | 
545 | <p>The <code>xhprof_lib</code> directory contains supporting code for
546 | display as well as analysis (computing flat profile info, computing
547 | diffs, aggregating data from multiple runs, etc.).
548 | 
549 | <li><p><b>Web server config: </b> You'll need to make sure that the
550 | <code>xhprof_html/</code> directory is accessible from your web server, and that
551 | your web server is setup to serve PHP scripts.
552 | 
553 | <li><p><b>Managing XHProf Runs</b>
554 | 
555 | <p>Clients have flexibility in how they save the XHProf raw data
556 | obtained from an XHProf run. The XHProf UI layer exposes an interface
557 | iXHProfRuns (see xhprof_lib/utils/xhprof_runs.php) that clients can
558 | implement. This allows the clients to tell the UI layer how to fetch
559 | the data corresponding to a XHProf run.
560 | 
561 | <p>The XHProf UI libaries come with a default file based
562 | implementation of the iXHProfRuns interface, namely
563 | "XHProfRuns_Default" (also in xhprof_lib/utils/xhprof_runs.php).
564 | This default implementation stores runs in the directory specified by
565 | <a href="#ini_file"><b>xhprof.output_dir</b></a> INI parameter.
566 | 
567 | <p>A XHProf run must be uniquely identified by a namespace and a run
568 | id.
569 | 
570 | 
571 | 
572 | <p><b>a) Saving XHProf data persistently</b>:
573 | 
574 | <p>Assuming you are using the default implementation
575 | <code><b>XHProfRuns_Default</b></code> of the
576 | <code><b>iXHProfRuns</b></code> interface, a typical XHProf run
577 | followed by the save step might look something like:
578 | 
579 | 
580 | <pre>
581 | // start profiling
582 | xhprof_enable();
583 | 
584 | // run program
585 | ....
586 | 
587 | // stop profiler
588 | $xhprof_data = xhprof_disable();
589 | 
590 | //
591 | // Saving the XHProf run
592 | // using the default implementation of iXHProfRuns.
593 | //
594 | include_once $XHPROF_ROOT . "/xhprof_lib/utils/xhprof_lib.php";
595 | include_once $XHPROF_ROOT . "/xhprof_lib/utils/xhprof_runs.php";
596 | 
597 | $xhprof_runs = new <b>XHProfRuns_Default()</b>;
598 | 
599 | // Save the run under a namespace "xhprof_foo".
600 | //
601 | // **NOTE**:
602 | // By default save_run() will automatically generate a unique
603 | // run id for you. [You can override that behavior by passing
604 | // a run id (optional arg) to the save_run() method instead.]
605 | //
606 | <b>$run_id = $xhprof_runs->save_run($xhprof_data, "xhprof_foo");</b>
607 | 
608 | echo "---------------\n".
609 |      "Assuming you have set up the http based UI for \n".
610 |      "XHProf at some address, you can view run at \n".
611 |      "http://&lt;xhprof-ui-address&gt;/index.php?run=$run_id&source=xhprof_foo\n".
612 |      "---------------\n";
613 | 
614 | </pre>
615 | 
616 | <p>The above should save the run as a file in the directory specified
617 | by the <code><b>xhprof.output_dir</b></code> INI parameter. The file's
618 | name might be something like
619 | <b><code>49bafaa3a3f66.xhprof_foo</code></b>; the two parts being the
620 | run id ("49bafaa3a3f66") and the namespace ("xhprof_foo"). [If you
621 | want to create/assign run ids yourself (such as a database sequence
622 | number, or a timestamp), you can explicitly pass in the run id to the
623 | <code>save_run</code> method.
624 | 
625 | 
626 | <p><b>b) Using your own implementation of iXHProfRuns</b>
627 | 
628 | <p> If you decide you want your XHProf runs to be stored differently
629 | (either in a compressed format, in an alternate place such as DB,
630 | etc.)  database, you'll need to implement a class that implements the
631 | iXHProfRuns() interface.
632 | 
633 | <p> You'll also need to modify the 3 main PHP entry pages (index.php,
634 | callgraph.php, typeahead.php) in the "xhprof_html/" directory to use
635 | the new class instead of the default class <code>XHProfRuns_Default</code>.
636 | Change this line in the 3 files.
637 | 
638 | <pre>
639 | $xhprof_runs_impl = new XHProfRuns_Default();
640 | </pre>
641 | 
642 | <p>You'll also need to "include" the file that implements your class in
643 | the above files.
644 | 
645 | 
646 | <li><p><b>Accessing runs from UI</b>
647 | 
648 | <p><b>a) Viewing a Single Run Report</b>
649 | 
650 | <p>To view the report for run id say &lt;run_id&gt; and namespace
651 | &lt;namespace&gt; use a URL of the form:
652 | 
653 | <p><code>
654 | http://&lt;xhprof-ui-address&gt;/index.php?run=&lt;run_id&gt;&source=&lt;namespace&gt;
655 | </code>
656 | 
657 | <p>For example,
658 | <p><code>
659 | http://&lt;xhprof-ui-address&gt;/index.php?run=49bafaa3a3f66&source=xhprof_foo
660 | </code>
661 | 
662 | 
663 | <p><b>b) Viewing a Diff Report</b>
664 | 
665 | <p>To view the report for run ids say &lt;run_id1&gt; and
666 | &lt;run_id2&gt; in namespace &lt;namespace&gt; use a URL of the form:
667 | 
668 | <p><code>
669 | http://&lt;xhprof-ui-address&gt;/index.php?<b>run1=&lt;run_id1&gt;&run2=&lt;run_id2&gt;</b>&source=&lt;namespace&gt;
670 | </code>
671 | 
672 | <p><b>c) Aggregate Report</b>
673 | 
674 | <p>You can also specify a set of run ids for which you want an aggregated view/report.
675 | 
676 | <p>Say you have three XHProf runs with ids 1, 2 & 3 in namespace
677 | "benchmark".  To view an aggregate report of these runs:
678 | 
679 | <ul><p><code>
680 | http://&lt;xhprof-ui-address&gt;/index.php?<b>run=1,2,3</b>&source=benchmark
681 | </code></p></ul>
682 | 
683 | <p><b>Weighted aggregations</b>: Further suppose that the above three runs
684 | correspond to three types of programs p1.php, p2.php and p3.php that
685 | typically occur in a mix of 20%, 30%, 50% respectively. To view an
686 | aggregate report that corresponds to a weighted average of these runs
687 | using:
688 | 
689 | <ul><p><code>
690 | http://&lt;xhprof-ui-address&gt;/index.php?<b>run=1,2,3&wts=20,30,50</b>&source=benchmark
691 | </code></p></ul>
692 | 
693 | 
694 | </ol>
695 | 
696 | <li><a name="production_notes"><h2>Notes on using XHProf in production</h2></a>
697 | 
698 | <p>Some observations/guidelines. Your mileage may vary:
699 | 
700 | <ul>
701 | 
702 | <li>CPU timer (getrusage) on Linux has high overheads. It is also
703 | coarse grained (millisec accuracy rather than microsec level) to be
704 | useful at function level. Therefore, the skew in reported numbers
705 | when using XHPROF_FLAGS_CPU mode tends to be higher.
706 | 
707 | <p>We recommend using elapsed time + memory profiling mode in
708 | production. [Note: The additional overhead of memory profiling
709 | mode is really low.]
710 | 
711 | <p><ul><pre><b>
712 |   // elapsed time profiling (default) + memory profiling
713 |   xhprof_enable(XHPROF_FLAGS_MEMORY);
714 | </b></pre>
715 | </ul></p>
716 | 
717 | 
718 | <li>Profiling a random sample of pages/requests works well in capturing
719 | data that is representative of your production workload.
720 | 
721 | <p>To profile say 1/10000 of your requests, instrument the beginning of
722 | your request processing with something along the lines of:
723 | 
724 | <p><ul><pre><code>
725 |  if (mt_rand(1, 10000) == 1) {
726 |    xhprof_enable(XHPROF_FLAGS_MEMORY);
727 |    $xhprof_on = true;
728 |  }
729 | </code></pre></ul></p>
730 | 
731 | <p>At the end of the request (or in a request shutdown function), you might
732 | then do something like:
733 | 
734 | <p><ul><pre><code>
735 |  if ($xhprof_on) {
736 |    // stop profiler
737 |    $xhprof_data = xhprof_disable();
738 | 
739 |    // save $xhprof_data somewhere (say a central DB)
740 |    ...
741 |  }
742 | </code></pre></ul></p>
743 | 
744 | <p> You can then rollup/aggregate these individual profiles by time
745 | (e.g., 5 minutely/hourly/daily basis), page/request type,or other
746 | dimensions using <a href="#xhprof_aggregate_runs"><code><b>xhprof_aggregate_runs()</b></code></a>.
747 | 
748 | </ul>
749 | 
750 | 
751 | <li><a name="sampling_mode"><h2>Lightweight Sampling Mode</h2></a>
752 | 
753 | <p>The xhprof extension also provides a very light weight <b>sampling
754 | mode</b>. The sampling interval is 0.1 secs. Samples record the full
755 | function call stack. The sampling mode can be useful if an extremely
756 | low overhead means of doing performance monitoring and diagnostics is
757 | desired.
758 | 
759 | <p> The relevant functions exposed by the extension for using the
760 | sampling mode are <code><b>xhprof_sample_enable()</b></code> and
761 | <code><b>xhprof_sample_disable()</b></code>.
762 | 
763 | 
764 | <p>[<b>TBD</b>: more detailed documentation on sampling mode.]
765 | 
766 | 
767 | <li><a name="misc"><h2>Additional Features</h2></a></li>
768 | 
769 | <p>The <code><b>xhprof_lib/utils/xhprof_lib.php</b></code> file contains
770 | additional library functions that can be used for manipulating/
771 | aggregating XHProf runs.
772 | 
773 | <p>For example:
774 | 
775 | <ul>
776 | 
777 | <a name="xhprof_aggregate_runs"></a>
778 | <p><li><code><b>xhprof_aggregate_runs()</b></code>:
779 | can be used to aggregate multiple XHProf runs into a single run. This
780 | can be helpful for building a system-wide "function-level" performance
781 | monitoring tool using XHProf. [For example, you might to roll up
782 | XHProf runs sampled from production periodically to generate hourly,
783 | daily, reports.]
784 | 
785 | <p><li><code><b>xhprof_prune_run()</b></code>: Aggregating large number of
786 | XHProf runs (especially if they correspond to different types of
787 | programs) can result in the callgraph size becoming too large. You can
788 | use <code>xhprof_prune_run</code> function to prune the callgraph data
789 | by editing out subtrees that account for a very small portion of the
790 | total time.
791 | 
792 | </ul>
793 | 
794 | 
795 | <ol>
796 | 
797 | </ol>
798 | 
799 | <li><a name="dependencies"><h2>Dependencies</h2></a></li>
800 | 
801 | <ul>
802 | <li><b>JQuery Javascript</b>: For tooltips and function name
803 | typeahead, we make use of JQuery's javascript libraries. JQuery is
804 | available under both a MIT and GPL licencse
805 | (http://docs.jquery.com/Licensing). The relevant JQuery code, used by
806 | XHProf, is in the <code>xhprof_html/jquery</code> subdirectory.
807 | 
808 | <li><b>dot (image generation utility):</b> The callgraph image
809 | visualization ([View Callgraph]) feature relies on the presence of
810 | Graphviz "dot" utility in your path. "dot" is a utility to
811 | draw/generate an image for a directed graph.
812 | 
813 | </ul>
814 | <li><a name="credits"><h2>Acknowledgements</h2></a>
815 | 
816 | <p>The HTML-based navigational interface for browsing profiler results
817 | is inspired by that of a similar tool that exists for Oracle's stored
818 | procedure language, PL/SQL. But that's where the similarity ends; the
819 | internals of the profiler itself are quite different.
820 | 
821 | </li>
822 | 
823 | </ol>
824 | 
825 | </body>
826 | </html>
827 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/docs/sample-callgraph-image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KickPeach/kickPeach/ec8ae05c34e8adeaa02ac210ceaa5a24ad668503/public/xhprof/xhprof_html/docs/sample-callgraph-image.jpg


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/docs/sample-diff-report-flat-view.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KickPeach/kickPeach/ec8ae05c34e8adeaa02ac210ceaa5a24ad668503/public/xhprof/xhprof_html/docs/sample-diff-report-flat-view.jpg


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/docs/sample-diff-report-parent-child-view.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KickPeach/kickPeach/ec8ae05c34e8adeaa02ac210ceaa5a24ad668503/public/xhprof/xhprof_html/docs/sample-diff-report-parent-child-view.jpg


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/docs/sample-flat-view.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KickPeach/kickPeach/ec8ae05c34e8adeaa02ac210ceaa5a24ad668503/public/xhprof/xhprof_html/docs/sample-flat-view.jpg


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/docs/sample-parent-child-view.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KickPeach/kickPeach/ec8ae05c34e8adeaa02ac210ceaa5a24ad668503/public/xhprof/xhprof_html/docs/sample-parent-child-view.jpg


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //  Copyright (c) 2009 Facebook
 3 | //
 4 | //  Licensed under the Apache License, Version 2.0 (the "License");
 5 | //  you may not use this file except in compliance with the License.
 6 | //  You may obtain a copy of the License at
 7 | //
 8 | //      http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | //  Unless required by applicable law or agreed to in writing, software
11 | //  distributed under the License is distributed on an "AS IS" BASIS,
12 | //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | //  See the License for the specific language governing permissions and
14 | //  limitations under the License.
15 | //
16 | 
17 | //
18 | // XHProf: A Hierarchical Profiler for PHP
19 | //
20 | // XHProf has two components:
21 | //
22 | //  * This module is the UI/reporting component, used
23 | //    for viewing results of XHProf runs from a browser.
24 | //
25 | //  * Data collection component: This is implemented
26 | //    as a PHP extension (XHProf).
27 | //
28 | //
29 | //
30 | // @author(s)  Kannan Muthukkaruppan
31 | //             Changhao Jiang
32 | //
33 | 
34 | // by default assume that xhprof_html & xhprof_lib directories
35 | // are at the same level.
36 | $GLOBALS['XHPROF_LIB_ROOT'] = dirname(__FILE__) . '/../xhprof_lib';
37 | 
38 | require_once $GLOBALS['XHPROF_LIB_ROOT'].'/display/xhprof.php';
39 | 
40 | // param name, its type, and default value
41 | $params = array('run'        => array(XHPROF_STRING_PARAM, ''),
42 |                 'wts'        => array(XHPROF_STRING_PARAM, ''),
43 |                 'symbol'     => array(XHPROF_STRING_PARAM, ''),
44 |                 'sort'       => array(XHPROF_STRING_PARAM, 'wt'), // wall time
45 |                 'run1'       => array(XHPROF_STRING_PARAM, ''),
46 |                 'run2'       => array(XHPROF_STRING_PARAM, ''),
47 |                 'source'     => array(XHPROF_STRING_PARAM, 'xhprof'),
48 |                 'all'        => array(XHPROF_UINT_PARAM, 0),
49 |                 );
50 | 
51 | // pull values of these params, and create named globals for each param
52 | xhprof_param_init($params);
53 | 
54 | /* reset params to be a array of variable names to values
55 |    by the end of this page, param should only contain values that need
56 |    to be preserved for the next page. unset all unwanted keys in $params.
57 |  */
58 | foreach ($params as $k => $v) {
59 |   $params[$k] = $$k;
60 | 
61 |   // unset key from params that are using default values. So URLs aren't
62 |   // ridiculously long.
63 |   if ($params[$k] == $v[1]) {
64 |     unset($params[$k]);
65 |   }
66 | }
67 | 
68 | echo "<html>";
69 | 
70 | echo "<head><title>XHProf: Hierarchical Profiler Report</title>";
71 | xhprof_include_js_css();
72 | echo "</head>";
73 | 
74 | echo "<body>";
75 | 
76 | $vbar  = ' class="vbar"';
77 | $vwbar = ' class="vwbar"';
78 | $vwlbar = ' class="vwlbar"';
79 | $vbbar = ' class="vbbar"';
80 | $vrbar = ' class="vrbar"';
81 | $vgbar = ' class="vgbar"';
82 | 
83 | $xhprof_runs_impl = new XHProfRuns_Default();
84 | 
85 | displayXHProfReport($xhprof_runs_impl, $params, $source, $run, $wts,
86 |                     $symbol, $sort, $run1, $run2);
87 | 
88 | 
89 | echo "</body>";
90 | echo "</html>";
91 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/jquery/indicator.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KickPeach/kickPeach/ec8ae05c34e8adeaa02ac210ceaa5a24ad668503/public/xhprof/xhprof_html/jquery/indicator.gif


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/jquery/jquery.autocomplete.css:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Autocomplete - jQuery plugin 1.0.2
 3 |  *
 4 |  * Copyright (c) 2007 Dylan Verheul, Dan G. Switzer, Anjesh Tuladhar, Jörn Zaefferer
 5 |  *
 6 |  * Dual licensed under the MIT and GPL licenses:
 7 |  *   http://www.opensource.org/licenses/mit-license.php
 8 |  *   http://www.gnu.org/licenses/gpl.html
 9 |  *
10 |  * Revision: $Id$
11 |  *
12 |  */
13 | 
14 | .ac_results {
15 | 	padding: 0px;
16 | 	border: 1px solid black;
17 | 	background-color: white;
18 | 	overflow: hidden;
19 | 	z-index: 99999;
20 | }
21 | 
22 | .ac_results ul {
23 | 	width: 100%;
24 | 	list-style-position: outside;
25 | 	list-style: none;
26 | 	padding: 0;
27 | 	margin: 0;
28 | }
29 | 
30 | .ac_results li {
31 | 	margin: 0px;
32 | 	padding: 2px 5px;
33 | 	cursor: default;
34 | 	display: block;
35 | 	/*
36 | 	if width will be 100% horizontal scrollbar will apear
37 | 	when scroll mode will be used
38 | 	*/
39 | 	/*width: 100%;*/
40 | 	font: menu;
41 | 	font-size: 12px;
42 | 	/*
43 | 	it is very important, if line-height not setted or setted
44 | 	in relative units scroll will be broken in firefox
45 | 	*/
46 | 	line-height: 16px;
47 | 	overflow: hidden;
48 | }
49 | 
50 | .ac_loading {
51 | 	background: white url('indicator.gif') right center no-repeat;
52 | }
53 | 
54 | .ac_odd {
55 | 	background-color: #eee;
56 | }
57 | 
58 | .ac_over {
59 | 	background-color: #0A246A;
60 | 	color: white;
61 | }
62 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/jquery/jquery.autocomplete.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Autocomplete - jQuery plugin 1.0.2
  3 |  *
  4 |  * Copyright (c) 2007 Dylan Verheul, Dan G. Switzer, Anjesh Tuladhar, Jörn Zaefferer
  5 |  *
  6 |  * Dual licensed under the MIT and GPL licenses:
  7 |  *   http://www.opensource.org/licenses/mit-license.php
  8 |  *   http://www.gnu.org/licenses/gpl.html
  9 |  *
 10 |  * Revision: $Id: jquery.autocomplete.js,v 1.1.1.1 2009-03-17 18:35:18 kannan Exp $
 11 |  *
 12 |  */
 13 | 
 14 | ;(function($) {
 15 | 	
 16 | $.fn.extend({
 17 | 	autocomplete: function(urlOrData, options) {
 18 | 		var isUrl = typeof urlOrData == "string";
 19 | 		options = $.extend({}, $.Autocompleter.defaults, {
 20 | 			url: isUrl ? urlOrData : null,
 21 | 			data: isUrl ? null : urlOrData,
 22 | 			delay: isUrl ? $.Autocompleter.defaults.delay : 10,
 23 | 			max: options && !options.scroll ? 10 : 150
 24 | 		}, options);
 25 | 		
 26 | 		// if highlight is set to false, replace it with a do-nothing function
 27 | 		options.highlight = options.highlight || function(value) { return value; };
 28 | 		
 29 | 		// if the formatMatch option is not specified, then use formatItem for backwards compatibility
 30 | 		options.formatMatch = options.formatMatch || options.formatItem;
 31 | 		
 32 | 		return this.each(function() {
 33 | 			new $.Autocompleter(this, options);
 34 | 		});
 35 | 	},
 36 | 	result: function(handler) {
 37 | 		return this.bind("result", handler);
 38 | 	},
 39 | 	search: function(handler) {
 40 | 		return this.trigger("search", [handler]);
 41 | 	},
 42 | 	flushCache: function() {
 43 | 		return this.trigger("flushCache");
 44 | 	},
 45 | 	setOptions: function(options){
 46 | 		return this.trigger("setOptions", [options]);
 47 | 	},
 48 | 	unautocomplete: function() {
 49 | 		return this.trigger("unautocomplete");
 50 | 	}
 51 | });
 52 | 
 53 | $.Autocompleter = function(input, options) {
 54 | 
 55 | 	var KEY = {
 56 | 		UP: 38,
 57 | 		DOWN: 40,
 58 | 		DEL: 46,
 59 | 		TAB: 9,
 60 | 		RETURN: 13,
 61 | 		ESC: 27,
 62 | 		COMMA: 188,
 63 | 		PAGEUP: 33,
 64 | 		PAGEDOWN: 34,
 65 | 		BACKSPACE: 8
 66 | 	};
 67 | 
 68 | 	// Create $ object for input element
 69 | 	var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);
 70 | 
 71 | 	var timeout;
 72 | 	var previousValue = "";
 73 | 	var cache = $.Autocompleter.Cache(options);
 74 | 	var hasFocus = 0;
 75 | 	var lastKeyPressCode;
 76 | 	var config = {
 77 | 		mouseDownOnSelect: false
 78 | 	};
 79 | 	var select = $.Autocompleter.Select(options, input, selectCurrent, config);
 80 | 	
 81 | 	var blockSubmit;
 82 | 	
 83 | 	// prevent form submit in opera when selecting with return key
 84 | 	$.browser.opera && $(input.form).bind("submit.autocomplete", function() {
 85 | 		if (blockSubmit) {
 86 | 			blockSubmit = false;
 87 | 			return false;
 88 | 		}
 89 | 	});
 90 | 	
 91 | 	// only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all
 92 | 	$input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {
 93 | 		// track last key pressed
 94 | 		lastKeyPressCode = event.keyCode;
 95 | 		switch(event.keyCode) {
 96 | 		
 97 | 			case KEY.UP:
 98 | 				event.preventDefault();
 99 | 				if ( select.visible() ) {
100 | 					select.prev();
101 | 				} else {
102 | 					onChange(0, true);
103 | 				}
104 | 				break;
105 | 				
106 | 			case KEY.DOWN:
107 | 				event.preventDefault();
108 | 				if ( select.visible() ) {
109 | 					select.next();
110 | 				} else {
111 | 					onChange(0, true);
112 | 				}
113 | 				break;
114 | 				
115 | 			case KEY.PAGEUP:
116 | 				event.preventDefault();
117 | 				if ( select.visible() ) {
118 | 					select.pageUp();
119 | 				} else {
120 | 					onChange(0, true);
121 | 				}
122 | 				break;
123 | 				
124 | 			case KEY.PAGEDOWN:
125 | 				event.preventDefault();
126 | 				if ( select.visible() ) {
127 | 					select.pageDown();
128 | 				} else {
129 | 					onChange(0, true);
130 | 				}
131 | 				break;
132 | 			
133 | 			// matches also semicolon
134 | 			case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:
135 | 			case KEY.TAB:
136 | 			case KEY.RETURN:
137 | 				if( selectCurrent() ) {
138 | 					// stop default to prevent a form submit, Opera needs special handling
139 | 					event.preventDefault();
140 | 					blockSubmit = true;
141 | 					return false;
142 | 				}
143 | 				break;
144 | 				
145 | 			case KEY.ESC:
146 | 				select.hide();
147 | 				break;
148 | 				
149 | 			default:
150 | 				clearTimeout(timeout);
151 | 				timeout = setTimeout(onChange, options.delay);
152 | 				break;
153 | 		}
154 | 	}).focus(function(){
155 | 		// track whether the field has focus, we shouldn't process any
156 | 		// results if the field no longer has focus
157 | 		hasFocus++;
158 | 	}).blur(function() {
159 | 		hasFocus = 0;
160 | 		if (!config.mouseDownOnSelect) {
161 | 			hideResults();
162 | 		}
163 | 	}).click(function() {
164 | 		// show select when clicking in a focused field
165 | 		if ( hasFocus++ > 1 && !select.visible() ) {
166 | 			onChange(0, true);
167 | 		}
168 | 	}).bind("search", function() {
169 | 		// TODO why not just specifying both arguments?
170 | 		var fn = (arguments.length > 1) ? arguments[1] : null;
171 | 		function findValueCallback(q, data) {
172 | 			var result;
173 | 			if( data && data.length ) {
174 | 				for (var i=0; i < data.length; i++) {
175 | 					if( data[i].result.toLowerCase() == q.toLowerCase() ) {
176 | 						result = data[i];
177 | 						break;
178 | 					}
179 | 				}
180 | 			}
181 | 			if( typeof fn == "function" ) fn(result);
182 | 			else $input.trigger("result", result && [result.data, result.value]);
183 | 		}
184 | 		$.each(trimWords($input.val()), function(i, value) {
185 | 			request(value, findValueCallback, findValueCallback);
186 | 		});
187 | 	}).bind("flushCache", function() {
188 | 		cache.flush();
189 | 	}).bind("setOptions", function() {
190 | 		$.extend(options, arguments[1]);
191 | 		// if we've updated the data, repopulate
192 | 		if ( "data" in arguments[1] )
193 | 			cache.populate();
194 | 	}).bind("unautocomplete", function() {
195 | 		select.unbind();
196 | 		$input.unbind();
197 | 		$(input.form).unbind(".autocomplete");
198 | 	});
199 | 	
200 | 	
201 | 	function selectCurrent() {
202 | 		var selected = select.selected();
203 | 		if( !selected )
204 | 			return false;
205 | 		
206 | 		var v = selected.result;
207 | 		previousValue = v;
208 | 		
209 | 		if ( options.multiple ) {
210 | 			var words = trimWords($input.val());
211 | 			if ( words.length > 1 ) {
212 | 				v = words.slice(0, words.length - 1).join( options.multipleSeparator ) + options.multipleSeparator + v;
213 | 			}
214 | 			v += options.multipleSeparator;
215 | 		}
216 | 		
217 | 		$input.val(v);
218 | 		hideResultsNow();
219 | 		$input.trigger("result", [selected.data, selected.value]);
220 | 		return true;
221 | 	}
222 | 	
223 | 	function onChange(crap, skipPrevCheck) {
224 | 		if( lastKeyPressCode == KEY.DEL ) {
225 | 			select.hide();
226 | 			return;
227 | 		}
228 | 		
229 | 		var currentValue = $input.val();
230 | 		
231 | 		if ( !skipPrevCheck && currentValue == previousValue )
232 | 			return;
233 | 		
234 | 		previousValue = currentValue;
235 | 		
236 | 		currentValue = lastWord(currentValue);
237 | 		if ( currentValue.length >= options.minChars) {
238 | 			$input.addClass(options.loadingClass);
239 | 			if (!options.matchCase)
240 | 				currentValue = currentValue.toLowerCase();
241 | 			request(currentValue, receiveData, hideResultsNow);
242 | 		} else {
243 | 			stopLoading();
244 | 			select.hide();
245 | 		}
246 | 	};
247 | 	
248 | 	function trimWords(value) {
249 | 		if ( !value ) {
250 | 			return [""];
251 | 		}
252 | 		var words = value.split( options.multipleSeparator );
253 | 		var result = [];
254 | 		$.each(words, function(i, value) {
255 | 			if ( $.trim(value) )
256 | 				result[i] = $.trim(value);
257 | 		});
258 | 		return result;
259 | 	}
260 | 	
261 | 	function lastWord(value) {
262 | 		if ( !options.multiple )
263 | 			return value;
264 | 		var words = trimWords(value);
265 | 		return words[words.length - 1];
266 | 	}
267 | 	
268 | 	// fills in the input box w/the first match (assumed to be the best match)
269 | 	// q: the term entered
270 | 	// sValue: the first matching result
271 | 	function autoFill(q, sValue){
272 | 		// autofill in the complete box w/the first match as long as the user hasn't entered in more data
273 | 		// if the last user key pressed was backspace, don't autofill
274 | 		if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != KEY.BACKSPACE ) {
275 | 			// fill in the value (keep the case the user has typed)
276 | 			$input.val($input.val() + sValue.substring(lastWord(previousValue).length));
277 | 			// select the portion of the value not typed by the user (so the next character will erase)
278 | 			$.Autocompleter.Selection(input, previousValue.length, previousValue.length + sValue.length);
279 | 		}
280 | 	};
281 | 
282 | 	function hideResults() {
283 | 		clearTimeout(timeout);
284 | 		timeout = setTimeout(hideResultsNow, 200);
285 | 	};
286 | 
287 | 	function hideResultsNow() {
288 | 		var wasVisible = select.visible();
289 | 		select.hide();
290 | 		clearTimeout(timeout);
291 | 		stopLoading();
292 | 		if (options.mustMatch) {
293 | 			// call search and run callback
294 | 			$input.search(
295 | 				function (result){
296 | 					// if no value found, clear the input box
297 | 					if( !result ) {
298 | 						if (options.multiple) {
299 | 							var words = trimWords($input.val()).slice(0, -1);
300 | 							$input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );
301 | 						}
302 | 						else
303 | 							$input.val( "" );
304 | 					}
305 | 				}
306 | 			);
307 | 		}
308 | 		if (wasVisible)
309 | 			// position cursor at end of input field
310 | 			$.Autocompleter.Selection(input, input.value.length, input.value.length);
311 | 	};
312 | 
313 | 	function receiveData(q, data) {
314 | 		if ( data && data.length && hasFocus ) {
315 | 			stopLoading();
316 | 			select.display(data, q);
317 | 			autoFill(q, data[0].value);
318 | 			select.show();
319 | 		} else {
320 | 			hideResultsNow();
321 | 		}
322 | 	};
323 | 
324 | 	function request(term, success, failure) {
325 | 		if (!options.matchCase)
326 | 			term = term.toLowerCase();
327 | 		var data = cache.load(term);
328 | 		// recieve the cached data
329 | 		if (data && data.length) {
330 | 			success(term, data);
331 | 		// if an AJAX url has been supplied, try loading the data now
332 | 		} else if( (typeof options.url == "string") && (options.url.length > 0) ){
333 | 			
334 | 			var extraParams = {
335 | 				timestamp: +new Date()
336 | 			};
337 | 			$.each(options.extraParams, function(key, param) {
338 | 				extraParams[key] = typeof param == "function" ? param() : param;
339 | 			});
340 | 			
341 | 			$.ajax({
342 | 				// try to leverage ajaxQueue plugin to abort previous requests
343 | 				mode: "abort",
344 | 				// limit abortion to this input
345 | 				port: "autocomplete" + input.name,
346 | 				dataType: options.dataType,
347 | 				url: options.url,
348 | 				data: $.extend({
349 | 					q: lastWord(term),
350 | 					limit: options.max
351 | 				}, extraParams),
352 | 				success: function(data) {
353 | 					var parsed = options.parse && options.parse(data) || parse(data);
354 | 					cache.add(term, parsed);
355 | 					success(term, parsed);
356 | 				}
357 | 			});
358 | 		} else {
359 | 			// if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match
360 | 			select.emptyList();
361 | 			failure(term);
362 | 		}
363 | 	};
364 | 	
365 | 	function parse(data) {
366 | 		var parsed = [];
367 | 		var rows = data.split("\n");
368 | 		for (var i=0; i < rows.length; i++) {
369 | 			var row = $.trim(rows[i]);
370 | 			if (row) {
371 | 				row = row.split("|");
372 | 				parsed[parsed.length] = {
373 | 					data: row,
374 | 					value: row[0],
375 | 					result: options.formatResult && options.formatResult(row, row[0]) || row[0]
376 | 				};
377 | 			}
378 | 		}
379 | 		return parsed;
380 | 	};
381 | 
382 | 	function stopLoading() {
383 | 		$input.removeClass(options.loadingClass);
384 | 	};
385 | 
386 | };
387 | 
388 | $.Autocompleter.defaults = {
389 | 	inputClass: "ac_input",
390 | 	resultsClass: "ac_results",
391 | 	loadingClass: "ac_loading",
392 | 	minChars: 1,
393 | 	delay: 400,
394 | 	matchCase: false,
395 | 	matchSubset: true,
396 | 	matchContains: false,
397 | 	cacheLength: 10,
398 | 	max: 100,
399 | 	mustMatch: false,
400 | 	extraParams: {},
401 | 	selectFirst: true,
402 | 	formatItem: function(row) { return row[0]; },
403 | 	formatMatch: null,
404 | 	autoFill: false,
405 | 	width: 0,
406 | 	multiple: false,
407 | 	multipleSeparator: ", ",
408 | 	highlight: function(value, term) {
409 | 		return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");
410 | 	},
411 |     scroll: true,
412 |     scrollHeight: 180
413 | };
414 | 
415 | $.Autocompleter.Cache = function(options) {
416 | 
417 | 	var data = {};
418 | 	var length = 0;
419 | 	
420 | 	function matchSubset(s, sub) {
421 | 		if (!options.matchCase) 
422 | 			s = s.toLowerCase();
423 | 		var i = s.indexOf(sub);
424 | 		if (i == -1) return false;
425 | 		return i == 0 || options.matchContains;
426 | 	};
427 | 	
428 | 	function add(q, value) {
429 | 		if (length > options.cacheLength){
430 | 			flush();
431 | 		}
432 | 		if (!data[q]){ 
433 | 			length++;
434 | 		}
435 | 		data[q] = value;
436 | 	}
437 | 	
438 | 	function populate(){
439 | 		if( !options.data ) return false;
440 | 		// track the matches
441 | 		var stMatchSets = {},
442 | 			nullData = 0;
443 | 
444 | 		// no url was specified, we need to adjust the cache length to make sure it fits the local data store
445 | 		if( !options.url ) options.cacheLength = 1;
446 | 		
447 | 		// track all options for minChars = 0
448 | 		stMatchSets[""] = [];
449 | 		
450 | 		// loop through the array and create a lookup structure
451 | 		for ( var i = 0, ol = options.data.length; i < ol; i++ ) {
452 | 			var rawValue = options.data[i];
453 | 			// if rawValue is a string, make an array otherwise just reference the array
454 | 			rawValue = (typeof rawValue == "string") ? [rawValue] : rawValue;
455 | 			
456 | 			var value = options.formatMatch(rawValue, i+1, options.data.length);
457 | 			if ( value === false )
458 | 				continue;
459 | 				
460 | 			var firstChar = value.charAt(0).toLowerCase();
461 | 			// if no lookup array for this character exists, look it up now
462 | 			if( !stMatchSets[firstChar] ) 
463 | 				stMatchSets[firstChar] = [];
464 | 
465 | 			// if the match is a string
466 | 			var row = {
467 | 				value: value,
468 | 				data: rawValue,
469 | 				result: options.formatResult && options.formatResult(rawValue) || value
470 | 			};
471 | 			
472 | 			// push the current match into the set list
473 | 			stMatchSets[firstChar].push(row);
474 | 
475 | 			// keep track of minChars zero items
476 | 			if ( nullData++ < options.max ) {
477 | 				stMatchSets[""].push(row);
478 | 			}
479 | 		};
480 | 
481 | 		// add the data items to the cache
482 | 		$.each(stMatchSets, function(i, value) {
483 | 			// increase the cache size
484 | 			options.cacheLength++;
485 | 			// add to the cache
486 | 			add(i, value);
487 | 		});
488 | 	}
489 | 	
490 | 	// populate any existing data
491 | 	setTimeout(populate, 25);
492 | 	
493 | 	function flush(){
494 | 		data = {};
495 | 		length = 0;
496 | 	}
497 | 	
498 | 	return {
499 | 		flush: flush,
500 | 		add: add,
501 | 		populate: populate,
502 | 		load: function(q) {
503 | 			if (!options.cacheLength || !length)
504 | 				return null;
505 | 			/* 
506 | 			 * if dealing w/local data and matchContains than we must make sure
507 | 			 * to loop through all the data collections looking for matches
508 | 			 */
509 | 			if( !options.url && options.matchContains ){
510 | 				// track all matches
511 | 				var csub = [];
512 | 				// loop through all the data grids for matches
513 | 				for( var k in data ){
514 | 					// don't search through the stMatchSets[""] (minChars: 0) cache
515 | 					// this prevents duplicates
516 | 					if( k.length > 0 ){
517 | 						var c = data[k];
518 | 						$.each(c, function(i, x) {
519 | 							// if we've got a match, add it to the array
520 | 							if (matchSubset(x.value, q)) {
521 | 								csub.push(x);
522 | 							}
523 | 						});
524 | 					}
525 | 				}				
526 | 				return csub;
527 | 			} else 
528 | 			// if the exact item exists, use it
529 | 			if (data[q]){
530 | 				return data[q];
531 | 			} else
532 | 			if (options.matchSubset) {
533 | 				for (var i = q.length - 1; i >= options.minChars; i--) {
534 | 					var c = data[q.substr(0, i)];
535 | 					if (c) {
536 | 						var csub = [];
537 | 						$.each(c, function(i, x) {
538 | 							if (matchSubset(x.value, q)) {
539 | 								csub[csub.length] = x;
540 | 							}
541 | 						});
542 | 						return csub;
543 | 					}
544 | 				}
545 | 			}
546 | 			return null;
547 | 		}
548 | 	};
549 | };
550 | 
551 | $.Autocompleter.Select = function (options, input, select, config) {
552 | 	var CLASSES = {
553 | 		ACTIVE: "ac_over"
554 | 	};
555 | 	
556 | 	var listItems,
557 | 		active = -1,
558 | 		data,
559 | 		term = "",
560 | 		needsInit = true,
561 | 		element,
562 | 		list;
563 | 	
564 | 	// Create results
565 | 	function init() {
566 | 		if (!needsInit)
567 | 			return;
568 | 		element = $("<div/>")
569 | 		.hide()
570 | 		.addClass(options.resultsClass)
571 | 		.css("position", "absolute")
572 | 		.appendTo(document.body);
573 | 	
574 | 		list = $("<ul/>").appendTo(element).mouseover( function(event) {
575 | 			if(target(event).nodeName && target(event).nodeName.toUpperCase() == 'LI') {
576 | 	            active = $("li", list).removeClass(CLASSES.ACTIVE).index(target(event));
577 | 			    $(target(event)).addClass(CLASSES.ACTIVE);            
578 | 	        }
579 | 		}).click(function(event) {
580 | 			$(target(event)).addClass(CLASSES.ACTIVE);
581 | 			select();
582 | 			// TODO provide option to avoid setting focus again after selection? useful for cleanup-on-focus
583 | 			input.focus();
584 | 			return false;
585 | 		}).mousedown(function() {
586 | 			config.mouseDownOnSelect = true;
587 | 		}).mouseup(function() {
588 | 			config.mouseDownOnSelect = false;
589 | 		});
590 | 		
591 | 		if( options.width > 0 )
592 | 			element.css("width", options.width);
593 | 			
594 | 		needsInit = false;
595 | 	} 
596 | 	
597 | 	function target(event) {
598 | 		var element = event.target;
599 | 		while(element && element.tagName != "LI")
600 | 			element = element.parentNode;
601 | 		// more fun with IE, sometimes event.target is empty, just ignore it then
602 | 		if(!element)
603 | 			return [];
604 | 		return element;
605 | 	}
606 | 
607 | 	function moveSelect(step) {
608 | 		listItems.slice(active, active + 1).removeClass(CLASSES.ACTIVE);
609 | 		movePosition(step);
610 |         var activeItem = listItems.slice(active, active + 1).addClass(CLASSES.ACTIVE);
611 |         if(options.scroll) {
612 |             var offset = 0;
613 |             listItems.slice(0, active).each(function() {
614 | 				offset += this.offsetHeight;
615 | 			});
616 |             if((offset + activeItem[0].offsetHeight - list.scrollTop()) > list[0].clientHeight) {
617 |                 list.scrollTop(offset + activeItem[0].offsetHeight - list.innerHeight());
618 |             } else if(offset < list.scrollTop()) {
619 |                 list.scrollTop(offset);
620 |             }
621 |         }
622 | 	};
623 | 	
624 | 	function movePosition(step) {
625 | 		active += step;
626 | 		if (active < 0) {
627 | 			active = listItems.size() - 1;
628 | 		} else if (active >= listItems.size()) {
629 | 			active = 0;
630 | 		}
631 | 	}
632 | 	
633 | 	function limitNumberOfItems(available) {
634 | 		return options.max && options.max < available
635 | 			? options.max
636 | 			: available;
637 | 	}
638 | 	
639 | 	function fillList() {
640 | 		list.empty();
641 | 		var max = limitNumberOfItems(data.length);
642 | 		for (var i=0; i < max; i++) {
643 | 			if (!data[i])
644 | 				continue;
645 | 			var formatted = options.formatItem(data[i].data, i+1, max, data[i].value, term);
646 | 			if ( formatted === false )
647 | 				continue;
648 | 			var li = $("<li/>").html( options.highlight(formatted, term) ).addClass(i%2 == 0 ? "ac_even" : "ac_odd").appendTo(list)[0];
649 | 			$.data(li, "ac_data", data[i]);
650 | 		}
651 | 		listItems = list.find("li");
652 | 		if ( options.selectFirst ) {
653 | 			listItems.slice(0, 1).addClass(CLASSES.ACTIVE);
654 | 			active = 0;
655 | 		}
656 | 		// apply bgiframe if available
657 | 		if ( $.fn.bgiframe )
658 | 			list.bgiframe();
659 | 	}
660 | 	
661 | 	return {
662 | 		display: function(d, q) {
663 | 			init();
664 | 			data = d;
665 | 			term = q;
666 | 			fillList();
667 | 		},
668 | 		next: function() {
669 | 			moveSelect(1);
670 | 		},
671 | 		prev: function() {
672 | 			moveSelect(-1);
673 | 		},
674 | 		pageUp: function() {
675 | 			if (active != 0 && active - 8 < 0) {
676 | 				moveSelect( -active );
677 | 			} else {
678 | 				moveSelect(-8);
679 | 			}
680 | 		},
681 | 		pageDown: function() {
682 | 			if (active != listItems.size() - 1 && active + 8 > listItems.size()) {
683 | 				moveSelect( listItems.size() - 1 - active );
684 | 			} else {
685 | 				moveSelect(8);
686 | 			}
687 | 		},
688 | 		hide: function() {
689 | 			element && element.hide();
690 | 			listItems && listItems.removeClass(CLASSES.ACTIVE);
691 | 			active = -1;
692 | 		},
693 | 		visible : function() {
694 | 			return element && element.is(":visible");
695 | 		},
696 | 		current: function() {
697 | 			return this.visible() && (listItems.filter("." + CLASSES.ACTIVE)[0] || options.selectFirst && listItems[0]);
698 | 		},
699 | 		show: function() {
700 | 			var offset = $(input).offset();
701 | 			element.css({
702 | 				width: typeof options.width == "string" || options.width > 0 ? options.width : $(input).width(),
703 | 				top: offset.top + input.offsetHeight,
704 | 				left: offset.left
705 | 			}).show();
706 |             if(options.scroll) {
707 |                 list.scrollTop(0);
708 |                 list.css({
709 | 					maxHeight: options.scrollHeight,
710 | 					overflow: 'auto'
711 | 				});
712 | 				
713 |                 if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {
714 | 					var listHeight = 0;
715 | 					listItems.each(function() {
716 | 						listHeight += this.offsetHeight;
717 | 					});
718 | 					var scrollbarsVisible = listHeight > options.scrollHeight;
719 |                     list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );
720 | 					if (!scrollbarsVisible) {
721 | 						// IE doesn't recalculate width when scrollbar disappears
722 | 						listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );
723 | 					}
724 |                 }
725 |                 
726 |             }
727 | 		},
728 | 		selected: function() {
729 | 			var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);
730 | 			return selected && selected.length && $.data(selected[0], "ac_data");
731 | 		},
732 | 		emptyList: function (){
733 | 			list && list.empty();
734 | 		},
735 | 		unbind: function() {
736 | 			element && element.remove();
737 | 		}
738 | 	};
739 | };
740 | 
741 | $.Autocompleter.Selection = function(field, start, end) {
742 | 	if( field.createTextRange ){
743 | 		var selRange = field.createTextRange();
744 | 		selRange.collapse(true);
745 | 		selRange.moveStart("character", start);
746 | 		selRange.moveEnd("character", end);
747 | 		selRange.select();
748 | 	} else if( field.setSelectionRange ){
749 | 		field.setSelectionRange(start, end);
750 | 	} else {
751 | 		if( field.selectionStart ){
752 | 			field.selectionStart = start;
753 | 			field.selectionEnd = end;
754 | 		}
755 | 	}
756 | 	field.focus();
757 | };
758 | 
759 | })(jQuery);


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/jquery/jquery.tooltip.css:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * jQuery Tooltip plugin 1.3
 3 |  *
 4 |  * http://bassistance.de/jquery-plugins/jquery-plugin-tooltip/
 5 |  * http://docs.jquery.com/Plugins/Tooltip
 6 |  *
 7 |  * Copyright (c) 2006 - 2008 Jörn Zaefferer
 8 |  *
 9 |  * $Id$
10 |  *
11 |  * Dual licensed under the MIT and GPL licenses:
12 |  *   http://www.opensource.org/licenses/mit-license.php
13 |  *   http://www.gnu.org/licenses/gpl.html
14 |  */
15 | 
16 |  #tooltip {
17 | 	position: absolute;
18 | 	z-index: 3000;
19 | 	border: 1px solid #111;
20 | 	background-color: lightyellow;
21 | 	padding: 5px;
22 | 	opacity: 0.9;
23 | }
24 | #tooltip h3, #tooltip div { margin: 0; }
25 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/jquery/jquery.tooltip.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * jQuery Tooltip plugin 1.3
  3 |  *
  4 |  * http://bassistance.de/jquery-plugins/jquery-plugin-tooltip/
  5 |  * http://docs.jquery.com/Plugins/Tooltip
  6 |  *
  7 |  * Copyright (c) 2006 - 2008 Jörn Zaefferer
  8 |  *
  9 |  * $Id: jquery.tooltip.js,v 1.1.1.1 2009-03-17 18:35:18 kannan Exp $
 10 |  * 
 11 |  * Dual licensed under the MIT and GPL licenses:
 12 |  *   http://www.opensource.org/licenses/mit-license.php
 13 |  *   http://www.gnu.org/licenses/gpl.html
 14 |  */
 15 |  
 16 | ;(function($) {
 17 | 	
 18 | 		// the tooltip element
 19 | 	var helper = {},
 20 | 		// the current tooltipped element
 21 | 		current,
 22 | 		// the title of the current element, used for restoring
 23 | 		title,
 24 | 		// timeout id for delayed tooltips
 25 | 		tID,
 26 | 		// IE 5.5 or 6
 27 | 		IE = $.browser.msie && /MSIE\s(5\.5|6\.)/.test(navigator.userAgent),
 28 | 		// flag for mouse tracking
 29 | 		track = false;
 30 | 	
 31 | 	$.tooltip = {
 32 | 		blocked: false,
 33 | 		defaults: {
 34 | 			delay: 200,
 35 | 			fade: false,
 36 | 			showURL: true,
 37 | 			extraClass: "",
 38 | 			top: 15,
 39 | 			left: 15,
 40 | 			id: "tooltip"
 41 | 		},
 42 | 		block: function() {
 43 | 			$.tooltip.blocked = !$.tooltip.blocked;
 44 | 		}
 45 | 	};
 46 | 	
 47 | 	$.fn.extend({
 48 | 		tooltip: function(settings) {
 49 | 			settings = $.extend({}, $.tooltip.defaults, settings);
 50 | 			createHelper(settings);
 51 | 			return this.each(function() {
 52 | 					$.data(this, "tooltip", settings);
 53 | 					this.tOpacity = helper.parent.css("opacity");
 54 | 					// copy tooltip into its own expando and remove the title
 55 | 					this.tooltipText = this.title;
 56 | 					$(this).removeAttr("title");
 57 | 					// also remove alt attribute to prevent default tooltip in IE
 58 | 					this.alt = "";
 59 | 				})
 60 | 				.mouseover(save)
 61 | 				.mouseout(hide)
 62 | 				.click(hide);
 63 | 		},
 64 | 		fixPNG: IE ? function() {
 65 | 			return this.each(function () {
 66 | 				var image = $(this).css('backgroundImage');
 67 | 				if (image.match(/^url\(["']?(.*\.png)["']?\)$/i)) {
 68 | 					image = RegExp.$1;
 69 | 					$(this).css({
 70 | 						'backgroundImage': 'none',
 71 | 						'filter': "progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true, sizingMethod=crop, src='" + image + "')"
 72 | 					}).each(function () {
 73 | 						var position = $(this).css('position');
 74 | 						if (position != 'absolute' && position != 'relative')
 75 | 							$(this).css('position', 'relative');
 76 | 					});
 77 | 				}
 78 | 			});
 79 | 		} : function() { return this; },
 80 | 		unfixPNG: IE ? function() {
 81 | 			return this.each(function () {
 82 | 				$(this).css({'filter': '', backgroundImage: ''});
 83 | 			});
 84 | 		} : function() { return this; },
 85 | 		hideWhenEmpty: function() {
 86 | 			return this.each(function() {
 87 | 				$(this)[ $(this).html() ? "show" : "hide" ]();
 88 | 			});
 89 | 		},
 90 | 		url: function() {
 91 | 			return this.attr('href') || this.attr('src');
 92 | 		}
 93 | 	});
 94 | 	
 95 | 	function createHelper(settings) {
 96 | 		// there can be only one tooltip helper
 97 | 		if( helper.parent )
 98 | 			return;
 99 | 		// create the helper, h3 for title, div for url
100 | 		helper.parent = $('<div id="' + settings.id + '"><h3></h3><div class="body"></div><div class="url"></div></div>')
101 | 			// add to document
102 | 			.appendTo(document.body)
103 | 			// hide it at first
104 | 			.hide();
105 | 			
106 | 		// apply bgiframe if available
107 | 		if ( $.fn.bgiframe )
108 | 			helper.parent.bgiframe();
109 | 		
110 | 		// save references to title and url elements
111 | 		helper.title = $('h3', helper.parent);
112 | 		helper.body = $('div.body', helper.parent);
113 | 		helper.url = $('div.url', helper.parent);
114 | 	}
115 | 	
116 | 	function settings(element) {
117 | 		return $.data(element, "tooltip");
118 | 	}
119 | 	
120 | 	// main event handler to start showing tooltips
121 | 	function handle(event) {
122 | 		// show helper, either with timeout or on instant
123 | 		if( settings(this).delay )
124 | 			tID = setTimeout(show, settings(this).delay);
125 | 		else
126 | 			show();
127 | 		
128 | 		// if selected, update the helper position when the mouse moves
129 | 		track = !!settings(this).track;
130 | 		$(document.body).bind('mousemove', update);
131 | 			
132 | 		// update at least once
133 | 		update(event);
134 | 	}
135 | 	
136 | 	// save elements title before the tooltip is displayed
137 | 	function save() {
138 | 		// if this is the current source, or it has no title (occurs with click event), stop
139 | 		if ( $.tooltip.blocked || this == current || (!this.tooltipText && !settings(this).bodyHandler) )
140 | 			return;
141 | 
142 | 		// save current
143 | 		current = this;
144 | 		title = this.tooltipText;
145 | 		
146 | 		if ( settings(this).bodyHandler ) {
147 | 			helper.title.hide();
148 | 			var bodyContent = settings(this).bodyHandler.call(this);
149 | 			if (bodyContent.nodeType || bodyContent.jquery) {
150 | 				helper.body.empty().append(bodyContent)
151 | 			} else {
152 | 				helper.body.html( bodyContent );
153 | 			}
154 | 			helper.body.show();
155 | 		} else if ( settings(this).showBody ) {
156 | 			var parts = title.split(settings(this).showBody);
157 | 			helper.title.html(parts.shift()).show();
158 | 			helper.body.empty();
159 | 			for(var i = 0, part; (part = parts[i]); i++) {
160 | 				if(i > 0)
161 | 					helper.body.append("<br/>");
162 | 				helper.body.append(part);
163 | 			}
164 | 			helper.body.hideWhenEmpty();
165 | 		} else {
166 | 			helper.title.html(title).show();
167 | 			helper.body.hide();
168 | 		}
169 | 		
170 | 		// if element has href or src, add and show it, otherwise hide it
171 | 		if( settings(this).showURL && $(this).url() )
172 | 			helper.url.html( $(this).url().replace('http://', '') ).show();
173 | 		else 
174 | 			helper.url.hide();
175 | 		
176 | 		// add an optional class for this tip
177 | 		helper.parent.addClass(settings(this).extraClass);
178 | 
179 | 		// fix PNG background for IE
180 | 		if (settings(this).fixPNG )
181 | 			helper.parent.fixPNG();
182 | 			
183 | 		handle.apply(this, arguments);
184 | 	}
185 | 	
186 | 	// delete timeout and show helper
187 | 	function show() {
188 | 		tID = null;
189 | 		if ((!IE || !$.fn.bgiframe) && settings(current).fade) {
190 | 			if (helper.parent.is(":animated"))
191 | 				helper.parent.stop().show().fadeTo(settings(current).fade, current.tOpacity);
192 | 			else
193 | 				helper.parent.is(':visible') ? helper.parent.fadeTo(settings(current).fade, current.tOpacity) : helper.parent.fadeIn(settings(current).fade);
194 | 		} else {
195 | 			helper.parent.show();
196 | 		}
197 | 		update();
198 | 	}
199 | 	
200 | 	/**
201 | 	 * callback for mousemove
202 | 	 * updates the helper position
203 | 	 * removes itself when no current element
204 | 	 */
205 | 	function update(event)	{
206 | 		if($.tooltip.blocked)
207 | 			return;
208 | 		
209 | 		if (event && event.target.tagName == "OPTION") {
210 | 			return;
211 | 		}
212 | 		
213 | 		// stop updating when tracking is disabled and the tooltip is visible
214 | 		if ( !track && helper.parent.is(":visible")) {
215 | 			$(document.body).unbind('mousemove', update)
216 | 		}
217 | 		
218 | 		// if no current element is available, remove this listener
219 | 		if( current == null ) {
220 | 			$(document.body).unbind('mousemove', update);
221 | 			return;	
222 | 		}
223 | 		
224 | 		// remove position helper classes
225 | 		helper.parent.removeClass("viewport-right").removeClass("viewport-bottom");
226 | 		
227 | 		var left = helper.parent[0].offsetLeft;
228 | 		var top = helper.parent[0].offsetTop;
229 | 		if (event) {
230 | 			// position the helper 15 pixel to bottom right, starting from mouse position
231 | 			left = event.pageX + settings(current).left;
232 | 			top = event.pageY + settings(current).top;
233 | 			var right='auto';
234 | 			if (settings(current).positionLeft) {
235 | 				right = $(window).width() - left;
236 | 				left = 'auto';
237 | 			}
238 | 			helper.parent.css({
239 | 				left: left,
240 | 				right: right,
241 | 				top: top
242 | 			});
243 | 		}
244 | 		
245 | 		var v = viewport(),
246 | 			h = helper.parent[0];
247 | 		// check horizontal position
248 | 		if (v.x + v.cx < h.offsetLeft + h.offsetWidth) {
249 | 			left -= h.offsetWidth + 20 + settings(current).left;
250 | 			helper.parent.css({left: left + 'px'}).addClass("viewport-right");
251 | 		}
252 | 		// check vertical position
253 | 		if (v.y + v.cy < h.offsetTop + h.offsetHeight) {
254 | 			top -= h.offsetHeight + 20 + settings(current).top;
255 | 			helper.parent.css({top: top + 'px'}).addClass("viewport-bottom");
256 | 		}
257 | 	}
258 | 	
259 | 	function viewport() {
260 | 		return {
261 | 			x: $(window).scrollLeft(),
262 | 			y: $(window).scrollTop(),
263 | 			cx: $(window).width(),
264 | 			cy: $(window).height()
265 | 		};
266 | 	}
267 | 	
268 | 	// hide helper and restore added classes and the title
269 | 	function hide(event) {
270 | 		if($.tooltip.blocked)
271 | 			return;
272 | 		// clear timeout if possible
273 | 		if(tID)
274 | 			clearTimeout(tID);
275 | 		// no more current element
276 | 		current = null;
277 | 		
278 | 		var tsettings = settings(this);
279 | 		function complete() {
280 | 			helper.parent.removeClass( tsettings.extraClass ).hide().css("opacity", "");
281 | 		}
282 | 		if ((!IE || !$.fn.bgiframe) && tsettings.fade) {
283 | 			if (helper.parent.is(':animated'))
284 | 				helper.parent.stop().fadeTo(tsettings.fade, 0, complete);
285 | 			else
286 | 				helper.parent.stop().fadeOut(tsettings.fade, complete);
287 | 		} else
288 | 			complete();
289 | 		
290 | 		if( settings(this).fixPNG )
291 | 			helper.parent.unfixPNG();
292 | 	}
293 | 	
294 | })(jQuery);
295 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/js/xhprof_report.js:
--------------------------------------------------------------------------------
  1 | /*  Copyright (c) 2009 Facebook
  2 |  *
  3 |  *  Licensed under the Apache License, Version 2.0 (the "License");
  4 |  *  you may not use this file except in compliance with the License.
  5 |  *  You may obtain a copy of the License at
  6 |  *
  7 |  *      http://www.apache.org/licenses/LICENSE-2.0
  8 |  *
  9 |  *  Unless required by applicable law or agreed to in writing, software
 10 |  *  distributed under the License is distributed on an "AS IS" BASIS,
 11 |  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 |  *  See the License for the specific language governing permissions and
 13 |  *  limitations under the License.
 14 |  */
 15 | 
 16 | /**
 17 |  * Helper javascript functions for XHProf report tooltips.
 18 |  *
 19 |  * @author Kannan Muthukkaruppan
 20 |  */
 21 | 
 22 | // Take a string which is actually a number in comma separated format
 23 | // and return a string representing the absolute value of the number.
 24 | function stringAbs(x) {
 25 |   return x.replace("-", "");
 26 | }
 27 | 
 28 | // Takes a number in comma-separated string format, and
 29 | // returns a boolean to indicate if the number is negative
 30 | // or not.
 31 | function isNegative(x) {
 32 | 
 33 |   return (x.indexOf("-") == 0);
 34 | 
 35 | }
 36 | 
 37 | function addCommas(nStr)
 38 | {
 39 |   nStr += '';
 40 |   x = nStr.split('.');
 41 |   x1 = x[0];
 42 |   x2 = x.length > 1 ? '.' + x[1] : '';
 43 |   var rgx = /(\d+)(\d{3})/;
 44 |   while (rgx.test(x1)) {
 45 |     x1 = x1.replace(rgx, '$1' + ',' + '$2');
 46 |   }
 47 |   return x1 + x2;
 48 | }
 49 | 
 50 | // Mouseover tips for parent rows in parent/child report..
 51 | function ParentRowToolTip(cell, metric)
 52 | {
 53 |   var metric_val;
 54 |   var parent_metric_val;
 55 |   var parent_metric_pct_val;
 56 |   var col_index;
 57 |   var diff_text;
 58 | 
 59 |   row = cell.parentNode;
 60 |   tds = row.getElementsByTagName("td");
 61 | 
 62 |   parent_func    = tds[0].innerHTML;  // name
 63 | 
 64 |   if (diff_mode) {
 65 |     diff_text = " diff ";
 66 |   } else {
 67 |     diff_text = "";
 68 |   }
 69 | 
 70 |   s = '<center>';
 71 | 
 72 |   if (metric == "ct") {
 73 |     parent_ct      = tds[1].innerHTML;  // calls
 74 |     parent_ct_pct  = tds[2].innerHTML;
 75 | 
 76 |     func_ct = addCommas(func_ct);
 77 | 
 78 |     if (diff_mode) {
 79 |       s += 'There are ' + stringAbs(parent_ct) +
 80 |         (isNegative(parent_ct) ? ' fewer ' : ' more ') +
 81 |         ' calls to ' + func_name + ' from ' + parent_func + '<br>';
 82 | 
 83 |       text = " of diff in calls ";
 84 |     }  else {
 85 |       text = " of calls ";
 86 |     }
 87 | 
 88 |     s += parent_ct_pct + text + '(' + parent_ct + '/' + func_ct + ') to '
 89 |       + func_name + ' are from ' + parent_func + '<br>';
 90 |   } else {
 91 | 
 92 |     // help for other metrics such as wall time, user cpu time, memory usage
 93 |     col_index = metrics_col[metric];
 94 |     parent_metric_val     = tds[col_index].innerHTML;
 95 |     parent_metric_pct_val = tds[col_index+1].innerHTML;
 96 | 
 97 |     metric_val = addCommas(func_metrics[metric]);
 98 | 
 99 |     s += parent_metric_pct_val + '(' + parent_metric_val + '/' + metric_val
100 |       + ') of ' + metrics_desc[metric] +
101 |       (diff_mode ? ((isNegative(parent_metric_val) ?
102 |                     " decrease" : " increase")) : "") +
103 |       ' in ' + func_name + ' is due to calls from ' + parent_func + '<br>';
104 |   }
105 | 
106 |   s += '</center>';
107 | 
108 |   return s;
109 | }
110 | 
111 | // Mouseover tips for child rows in parent/child report..
112 | function ChildRowToolTip(cell, metric)
113 | {
114 |   var metric_val;
115 |   var child_metric_val;
116 |   var child_metric_pct_val;
117 |   var col_index;
118 |   var diff_text;
119 | 
120 |   row = cell.parentNode;
121 |   tds = row.getElementsByTagName("td");
122 | 
123 |   child_func   = tds[0].innerHTML;  // name
124 | 
125 |   if (diff_mode) {
126 |     diff_text = " diff ";
127 |   } else {
128 |     diff_text = "";
129 |   }
130 | 
131 |   s = '<center>';
132 | 
133 |   if (metric == "ct") {
134 | 
135 |     child_ct     = tds[1].innerHTML;  // calls
136 |     child_ct_pct = tds[2].innerHTML;
137 | 
138 |     s += func_name + ' called ' + child_func + ' ' + stringAbs(child_ct) +
139 |       (diff_mode ? (isNegative(child_ct) ? " fewer" : " more") : "" )
140 |         + ' times.<br>';
141 |     s += 'This accounts for ' + child_ct_pct + ' (' + child_ct
142 |         + '/' + total_child_ct
143 |         + ') of function calls made by '  + func_name + '.';
144 | 
145 |   } else {
146 | 
147 |     // help for other metrics such as wall time, user cpu time, memory usage
148 |     col_index = metrics_col[metric];
149 |     child_metric_val     = tds[col_index].innerHTML;
150 |     child_metric_pct_val = tds[col_index+1].innerHTML;
151 | 
152 |     metric_val = addCommas(func_metrics[metric]);
153 | 
154 |     if (child_func.indexOf("Exclusive Metrics") != -1) {
155 |       s += 'The exclusive ' + metrics_desc[metric] + diff_text
156 |         + ' for ' + func_name
157 |         + ' is ' + child_metric_val + " <br>";
158 | 
159 |       s += "which is " + child_metric_pct_val + " of the inclusive "
160 |         + metrics_desc[metric]
161 |         + diff_text + " for " + func_name + " (" + metric_val + ").";
162 | 
163 |     } else {
164 | 
165 |       s += child_func + ' when called from ' + func_name
166 |         + ' takes ' + stringAbs(child_metric_val)
167 |         + (diff_mode ? (isNegative(child_metric_val) ? " less" : " more") : "")
168 |         + " of " + metrics_desc[metric] + " <br>";
169 | 
170 |       s += "which is " + child_metric_pct_val + " of the inclusive "
171 |         + metrics_desc[metric]
172 |         + diff_text + " for " + func_name + " (" + metric_val + ").";
173 |     }
174 |   }
175 | 
176 |   s += '</center>';
177 | 
178 |   return s;
179 | }
180 | 
181 | $(document).ready(function() {
182 |   $('td[@metric]').tooltip(
183 |     { bodyHandler: function() {
184 |           var type = $(this).attr('type');
185 |           var metric = $(this).attr('metric');
186 |           if (type == 'Parent') {
187 |              return ParentRowToolTip(this, metric);
188 |           } else if (type == 'Child') {
189 |              return ChildRowToolTip(this, metric);
190 |           }
191 |       },
192 |       showURL : false
193 |     });
194 |   var cur_params = {} ;
195 |   $.each(location.search.replace('?','').split('&'), function(i, x) {
196 |     var y = x.split('='); cur_params[y[0]] = y[1];
197 |   });
198 |   $('input.function_typeahead')
199 |     .autocomplete('typeahead.php', { extraParams : cur_params })
200 |     .result(function(event, item) {
201 |       cur_params['symbol'] = item;
202 |       location.search = '?' + jQuery.param(cur_params);
203 |     });
204 | });
205 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_html/typeahead.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //  Copyright (c) 2009 Facebook
 3 | //
 4 | //  Licensed under the Apache License, Version 2.0 (the "License");
 5 | //  you may not use this file except in compliance with the License.
 6 | //  You may obtain a copy of the License at
 7 | //
 8 | //      http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | //  Unless required by applicable law or agreed to in writing, software
11 | //  distributed under the License is distributed on an "AS IS" BASIS,
12 | //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | //  See the License for the specific language governing permissions and
14 | //  limitations under the License.
15 | //
16 | 
17 | /**
18 |  * AJAX endpoint for XHProf function name typeahead.
19 |  *
20 |  * @author(s)  Kannan Muthukkaruppan
21 |  *             Changhao Jiang
22 |  */
23 | 
24 | // by default assume that xhprof_html & xhprof_lib directories
25 | // are at the same level.
26 | $GLOBALS['XHPROF_LIB_ROOT'] = dirname(__FILE__) . '/../xhprof_lib';
27 | 
28 | require_once $GLOBALS['XHPROF_LIB_ROOT'].'/display/xhprof.php';
29 | 
30 | $xhprof_runs_impl = new XHProfRuns_Default();
31 | 
32 | require_once $GLOBALS['XHPROF_LIB_ROOT'].'/display/typeahead_common.php';
33 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_lib/display/typeahead_common.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //  Copyright (c) 2009 Facebook
 3 | //
 4 | //  Licensed under the Apache License, Version 2.0 (the "License");
 5 | //  you may not use this file except in compliance with the License.
 6 | //  You may obtain a copy of the License at
 7 | //
 8 | //      http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | //  Unless required by applicable law or agreed to in writing, software
11 | //  distributed under the License is distributed on an "AS IS" BASIS,
12 | //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | //  See the License for the specific language governing permissions and
14 | //  limitations under the License.
15 | //
16 | 
17 | /**
18 |  * AJAX endpoint for XHProf function name typeahead is implemented
19 |  * as a thin wrapper around this file. The wrapper must set up
20 |  * the global $xhprof_runs_impl to correspond to an object that
21 |  * implements the iXHProfRuns interface.
22 |  *
23 |  * @author(s)  Kannan Muthukkaruppan
24 |  *             Changhao Jiang
25 |  */
26 | 
27 | 
28 | require_once $GLOBALS['XHPROF_LIB_ROOT'].'/utils/xhprof_lib.php';
29 | 
30 | // param name, its type, and default value
31 | $params = array('q'          => array(XHPROF_STRING_PARAM, ''),
32 |                 'run'        => array(XHPROF_STRING_PARAM, ''),
33 |                 'run1'       => array(XHPROF_STRING_PARAM, ''),
34 |                 'run2'       => array(XHPROF_STRING_PARAM, ''),
35 |                 'source'     => array(XHPROF_STRING_PARAM, 'xhprof'),
36 |                 );
37 | 
38 | // pull values of these params, and create named globals for each param
39 | xhprof_param_init($params);
40 | 
41 | if (!empty($run)) {
42 | 
43 |   // single run mode
44 |   $raw_data = $xhprof_runs_impl->get_run($run, $source, $desc_unused);
45 |   $functions = xhprof_get_matching_functions($q, $raw_data);
46 | 
47 | } else if (!empty($run1) && !empty($run2)) {
48 | 
49 |   // diff mode
50 |   $raw_data = $xhprof_runs_impl->get_run($run1, $source, $desc_unused);
51 |   $functions1 = xhprof_get_matching_functions($q, $raw_data);
52 | 
53 |   $raw_data = $xhprof_runs_impl->get_run($run2, $source, $desc_unused);
54 |   $functions2 = xhprof_get_matching_functions($q, $raw_data);
55 | 
56 | 
57 |   $functions = array_unique(array_merge($functions1, $functions2));
58 |   asort($functions);
59 | } else {
60 |   xhprof_error("no valid runs specified to typeahead endpoint");
61 |   $functions = array();
62 | }
63 | 
64 | // If exact match is present move it to the front
65 | if (in_array($q, $functions)) {
66 |   $old_functions = $functions;
67 | 
68 |   $functions = array($q);
69 |   foreach ($old_functions as $f) {
70 |     // exact match case has already been added to the front
71 |     if ($f != $q) {
72 |       $functions[] = $f;
73 |     }
74 |   }
75 | }
76 | 
77 | foreach ($functions as $f) {
78 |   echo $f."\n";
79 | }
80 | 
81 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_lib/utils/callgraph_utils.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | //  Copyright (c) 2009 Facebook
  3 | //
  4 | //  Licensed under the Apache License, Version 2.0 (the "License");
  5 | //  you may not use this file except in compliance with the License.
  6 | //  You may obtain a copy of the License at
  7 | //
  8 | //      http://www.apache.org/licenses/LICENSE-2.0
  9 | //
 10 | //  Unless required by applicable law or agreed to in writing, software
 11 | //  distributed under the License is distributed on an "AS IS" BASIS,
 12 | //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | //  See the License for the specific language governing permissions and
 14 | //  limitations under the License.
 15 | //
 16 | 
 17 | /*
 18 |  * This file contains callgraph image generation related XHProf utility
 19 |  * functions
 20 |  *
 21 |  */
 22 | 
 23 | // Supported ouput format
 24 | $xhprof_legal_image_types = array(
 25 |     "jpg" => 1,
 26 |     "gif" => 1,
 27 |     "png" => 1,
 28 |     "svg" => 1, // support scalable vector graphic
 29 |     "ps"  => 1,
 30 |     );
 31 | 
 32 | /**
 33 |  * Send an HTTP header with the response. You MUST use this function instead
 34 |  * of header() so that we can debug header issues because they're virtually
 35 |  * impossible to debug otherwise. If you try to commit header(), SVN will
 36 |  * reject your commit.
 37 |  *
 38 |  * @param string  HTTP header name, like 'Location'
 39 |  * @param string  HTTP header value, like 'http://www.example.com/'
 40 |  *
 41 |  */
 42 | function xhprof_http_header($name, $value) {
 43 | 
 44 |   if (!$name) {
 45 |     xhprof_error('http_header usage');
 46 |     return null;
 47 |   }
 48 | 
 49 |   if (!is_string($value)) {
 50 |     xhprof_error('http_header value not a string');
 51 |   }
 52 | 
 53 |   header($name.': '.$value, true);
 54 | }
 55 | 
 56 | /**
 57 |  * Genearte and send MIME header for the output image to client browser.
 58 |  *
 59 |  * @author cjiang
 60 |  */
 61 | function xhprof_generate_mime_header($type, $length) {
 62 |   switch ($type) {
 63 |     case 'jpg':
 64 |       $mime = 'image/jpeg';
 65 |       break;
 66 |     case 'gif':
 67 |       $mime = 'image/gif';
 68 |       break;
 69 |     case 'png':
 70 |       $mime = 'image/png';
 71 |       break;
 72 |     case 'svg':
 73 |       $mime = 'image/svg+xml'; // content type for scalable vector graphic
 74 |       break;
 75 |     case 'ps':
 76 |       $mime = 'application/postscript';
 77 |     default:
 78 |       $mime = false;
 79 |   }
 80 | 
 81 |   if ($mime) {
 82 |     xhprof_http_header('Content-type', $mime);
 83 |     xhprof_http_header('Content-length', (string)$length);
 84 |   }
 85 | }
 86 | 
 87 | /**
 88 |  * Generate image according to DOT script. This function will spawn a process
 89 |  * with "dot" command and pipe the "dot_script" to it and pipe out the
 90 |  * generated image content.
 91 |  *
 92 |  * @param dot_script, string, the script for DOT to generate the image.
 93 |  * @param type, one of the supported image types, see
 94 |  * $xhprof_legal_image_types.
 95 |  * @returns, binary content of the generated image on success. empty string on
 96 |  *           failure.
 97 |  *
 98 |  * @author cjiang
 99 |  */
100 | function xhprof_generate_image_by_dot($dot_script, $type) {
101 |   $descriptorspec = array(
102 |        // stdin is a pipe that the child will read from
103 |        0 => array("pipe", "r"),
104 |        // stdout is a pipe that the child will write to
105 |        1 => array("pipe", "w"),
106 |        // stderr is a pipe that the child will write to
107 |        2 => array("pipe", "w")
108 |        );
109 | 
110 |   $cmd = " dot -T".$type;
111 | 
112 |   $process = proc_open($cmd, $descriptorspec, $pipes, "/tmp", array());
113 |   if (is_resource($process)) {
114 |     fwrite($pipes[0], $dot_script);
115 |     fclose($pipes[0]);
116 | 
117 |     $output = stream_get_contents($pipes[1]);
118 | 
119 |     $err = stream_get_contents($pipes[2]);
120 |     if (!empty($err)) {
121 |       print "failed to execute cmd: \"$cmd\". stderr: `$err'\n";
122 |       exit;
123 |     }
124 | 
125 |     fclose($pipes[2]);
126 |     fclose($pipes[1]);
127 |     proc_close($process);
128 |     return $output;
129 |   }
130 |   print "failed to execute cmd \"$cmd\"";
131 |   exit();
132 | }
133 | 
134 | /*
135 |  * Get the children list of all nodes.
136 |  */
137 | function xhprof_get_children_table($raw_data) {
138 |   $children_table = array();
139 |   foreach ($raw_data as $parent_child => $info) {
140 |     list($parent, $child) = xhprof_parse_parent_child($parent_child);
141 |     if (!isset($children_table[$parent])) {
142 |       $children_table[$parent] = array($child);
143 |     } else {
144 |       $children_table[$parent][] = $child;
145 |     }
146 |   }
147 |   return $children_table;
148 | }
149 | 
150 | /**
151 |  * Generate DOT script from the given raw phprof data.
152 |  *
153 |  * @param raw_data, phprof profile data.
154 |  * @param threshold, float, the threshold value [0,1). The functions in the
155 |  *                   raw_data whose exclusive wall times ratio are below the
156 |  *                   threshold will be filtered out and won't apprear in the
157 |  *                   generated image.
158 |  * @param page, string(optional), the root node name. This can be used to
159 |  *              replace the 'main()' as the root node.
160 |  * @param func, string, the focus function.
161 |  * @param critical_path, bool, whether or not to display critical path with
162 |  *                             bold lines.
163 |  * @returns, string, the DOT script to generate image.
164 |  *
165 |  * @author cjiang
166 |  */
167 | function xhprof_generate_dot_script($raw_data, $threshold, $source, $page,
168 |                                     $func, $critical_path, $right=null,
169 |                                     $left=null) {
170 | 
171 |   $max_width = 5;
172 |   $max_height = 3.5;
173 |   $max_fontsize = 35;
174 |   $max_sizing_ratio = 20;
175 | 
176 |   $totals;
177 | 
178 |   if ($left === null) {
179 |     // init_metrics($raw_data, null, null);
180 |   }
181 |   $sym_table = xhprof_compute_flat_info($raw_data, $totals);
182 | 
183 |   if ($critical_path) {
184 |     $children_table = xhprof_get_children_table($raw_data);
185 |     $node = "main()";
186 |     $path = array();
187 |     $path_edges = array();
188 |     $visited = array();
189 |     while ($node) {
190 |       $visited[$node] = true;
191 |       if (isset($children_table[$node])) {
192 |         $max_child = null;
193 |         foreach ($children_table[$node] as $child) {
194 | 
195 |           if (isset($visited[$child])) {
196 |             continue;
197 |           }
198 |           if ($max_child === null ||
199 |             abs($raw_data[xhprof_build_parent_child_key($node,
200 |                                                         $child)]["wt"]) >
201 |             abs($raw_data[xhprof_build_parent_child_key($node,
202 |                                                         $max_child)]["wt"])) {
203 |             $max_child = $child;
204 |           }
205 |         }
206 |         if ($max_child !== null) {
207 |           $path[$max_child] = true;
208 |           $path_edges[xhprof_build_parent_child_key($node, $max_child)] = true;
209 |         }
210 |         $node = $max_child;
211 |       } else {
212 |         $node = null;
213 |       }
214 |     }
215 |   }
216 | 
217 |   // if it is a benchmark callgraph, we make the benchmarked function the root.
218 |  if ($source == "bm" && array_key_exists("main()", $sym_table)) {
219 |     $total_times = $sym_table["main()"]["ct"];
220 |     $remove_funcs = array("main()",
221 |                           "hotprofiler_disable",
222 |                           "call_user_func_array",
223 |                           "xhprof_disable");
224 | 
225 |     foreach ($remove_funcs as $cur_del_func) {
226 |       if (array_key_exists($cur_del_func, $sym_table) &&
227 |           $sym_table[$cur_del_func]["ct"] == $total_times) {
228 |         unset($sym_table[$cur_del_func]);
229 |       }
230 |     }
231 |   }
232 | 
233 |   // use the function to filter out irrelevant functions.
234 |   if (!empty($func)) {
235 |     $interested_funcs = array();
236 |     foreach ($raw_data as $parent_child => $info) {
237 |       list($parent, $child) = xhprof_parse_parent_child($parent_child);
238 |       if ($parent == $func || $child == $func) {
239 |         $interested_funcs[$parent] = 1;
240 |         $interested_funcs[$child] = 1;
241 |       }
242 |     }
243 |     foreach ($sym_table as $symbol => $info) {
244 |       if (!array_key_exists($symbol, $interested_funcs)) {
245 |         unset($sym_table[$symbol]);
246 |       }
247 |     }
248 |   }
249 | 
250 |   $result = "digraph call_graph {\n";
251 | 
252 |   // Filter out functions whose exclusive time ratio is below threshold, and
253 |   // also assign a unique integer id for each function to be generated. In the
254 |   // meantime, find the function with the most exclusive time (potentially the
255 |   // performance bottleneck).
256 |   $cur_id = 0; $max_wt = 0;
257 |   foreach ($sym_table as $symbol => $info) {
258 |     if (empty($func) && abs($info["wt"] / $totals["wt"]) < $threshold) {
259 |       unset($sym_table[$symbol]);
260 |       continue;
261 |     }
262 |     if ($max_wt == 0 || $max_wt < abs($info["excl_wt"])) {
263 |       $max_wt = abs($info["excl_wt"]);
264 |     }
265 |     $sym_table[$symbol]["id"] = $cur_id;
266 |     $cur_id ++;
267 |   }
268 | 
269 |   // Generate all nodes' information.
270 |   foreach ($sym_table as $symbol => $info) {
271 |     if ($info["excl_wt"] == 0) {
272 |       $sizing_factor = $max_sizing_ratio;
273 |     } else {
274 |       $sizing_factor = $max_wt / abs($info["excl_wt"]) ;
275 |       if ($sizing_factor > $max_sizing_ratio) {
276 |         $sizing_factor = $max_sizing_ratio;
277 |       }
278 |     }
279 |     $fillcolor = (($sizing_factor < 1.5) ?
280 |                   ", style=filled, fillcolor=red" : "");
281 | 
282 |     if ($critical_path) {
283 |       // highlight nodes along critical path.
284 |       if (!$fillcolor && array_key_exists($symbol, $path)) {
285 |         $fillcolor = ", style=filled, fillcolor=yellow";
286 |       }
287 |     }
288 | 
289 |     $fontsize = ", fontsize="
290 |                .(int)($max_fontsize / (($sizing_factor - 1) / 10 + 1));
291 | 
292 |     $width = ", width=".sprintf("%.1f", $max_width / $sizing_factor);
293 |     $height = ", height=".sprintf("%.1f", $max_height / $sizing_factor);
294 | 
295 |     if ($symbol == "main()") {
296 |       $shape = "octagon";
297 |       $name = "Total: ".($totals["wt"] / 1000.0)." ms\\n";
298 |       $name .= addslashes(isset($page) ? $page : $symbol);
299 |     } else {
300 |       $shape = "box";
301 |       $name = addslashes($symbol)."\\nInc: ". sprintf("%.3f",$info["wt"] / 1000) .
302 |               " ms (" . sprintf("%.1f%%", 100 * $info["wt"] / $totals["wt"]).")";
303 |     }
304 |     if ($left === null) {
305 |       $label = ", label=\"".$name."\\nExcl: "
306 |                .(sprintf("%.3f",$info["excl_wt"] / 1000.0))." ms ("
307 |                .sprintf("%.1f%%", 100 * $info["excl_wt"] / $totals["wt"])
308 |                . ")\\n".$info["ct"]." total calls\"";
309 |     } else {
310 |       if (isset($left[$symbol]) && isset($right[$symbol])) {
311 |          $label = ", label=\"".addslashes($symbol).
312 |                   "\\nInc: ".(sprintf("%.3f",$left[$symbol]["wt"] / 1000.0))
313 |                   ." ms - "
314 |                   .(sprintf("%.3f",$right[$symbol]["wt"] / 1000.0))." ms = "
315 |                   .(sprintf("%.3f",$info["wt"] / 1000.0))." ms".
316 |                   "\\nExcl: "
317 |                   .(sprintf("%.3f",$left[$symbol]["excl_wt"] / 1000.0))
318 |                   ." ms - ".(sprintf("%.3f",$right[$symbol]["excl_wt"] / 1000.0))
319 |                    ." ms = ".(sprintf("%.3f",$info["excl_wt"] / 1000.0))." ms".
320 |                   "\\nCalls: ".(sprintf("%.3f",$left[$symbol]["ct"]))." - "
321 |                    .(sprintf("%.3f",$right[$symbol]["ct"]))." = "
322 |                    .(sprintf("%.3f",$info["ct"]))."\"";
323 |       } else if (isset($left[$symbol])) {
324 |         $label = ", label=\"".addslashes($symbol).
325 |                   "\\nInc: ".(sprintf("%.3f",$left[$symbol]["wt"] / 1000.0))
326 |                    ." ms - 0 ms = ".(sprintf("%.3f",$info["wt"] / 1000.0))
327 |                    ." ms"."\\nExcl: "
328 |                    .(sprintf("%.3f",$left[$symbol]["excl_wt"] / 1000.0))
329 |                    ." ms - 0 ms = "
330 |                    .(sprintf("%.3f",$info["excl_wt"] / 1000.0))." ms".
331 |                   "\\nCalls: ".(sprintf("%.3f",$left[$symbol]["ct"]))." - 0 = "
332 |                   .(sprintf("%.3f",$info["ct"]))."\"";
333 |       } else {
334 |         $label = ", label=\"".addslashes($symbol).
335 |                   "\\nInc: 0 ms - "
336 |                   .(sprintf("%.3f",$right[$symbol]["wt"] / 1000.0))
337 |                   ." ms = ".(sprintf("%.3f",$info["wt"] / 1000.0))." ms".
338 |                   "\\nExcl: 0 ms - "
339 |                   .(sprintf("%.3f",$right[$symbol]["excl_wt"] / 1000.0))
340 |                   ." ms = ".(sprintf("%.3f",$info["excl_wt"] / 1000.0))." ms".
341 |                   "\\nCalls: 0 - ".(sprintf("%.3f",$right[$symbol]["ct"]))
342 |                   ." = ".(sprintf("%.3f",$info["ct"]))."\"";
343 |       }
344 |     }
345 |     $result .= "N" . $sym_table[$symbol]["id"];
346 |     $result .= "[shape=$shape ".$label.$width
347 |                .$height.$fontsize.$fillcolor."];\n";
348 |   }
349 | 
350 |   // Generate all the edges' information.
351 |   foreach ($raw_data as $parent_child => $info) {
352 |     list($parent, $child) = xhprof_parse_parent_child($parent_child);
353 | 
354 |     if (isset($sym_table[$parent]) && isset($sym_table[$child]) &&
355 |         (empty($func) ||
356 |          (!empty($func) && ($parent == $func || $child == $func)))) {
357 | 
358 |       $label = $info["ct"] == 1 ? $info["ct"]." call" : $info["ct"]." calls";
359 | 
360 |       $headlabel = $sym_table[$child]["wt"] > 0 ?
361 |                   sprintf("%.1f%%", 100 * $info["wt"]
362 |                                     / $sym_table[$child]["wt"])
363 |                   : "0.0%";
364 | 
365 |       $taillabel = ($sym_table[$parent]["wt"] > 0) ?
366 |         sprintf("%.1f%%",
367 |                 100 * $info["wt"] /
368 |                 ($sym_table[$parent]["wt"] - $sym_table["$parent"]["excl_wt"]))
369 |         : "0.0%";
370 | 
371 |       $linewidth = 1;
372 |       $arrow_size = 1;
373 | 
374 |       if ($critical_path &&
375 |           isset($path_edges[xhprof_build_parent_child_key($parent, $child)])) {
376 |         $linewidth = 10; $arrow_size = 2;
377 |       }
378 | 
379 |       $result .= "N" . $sym_table[$parent]["id"] . " -> N"
380 |                  . $sym_table[$child]["id"];
381 |       $result .= "[arrowsize=$arrow_size, style=\"setlinewidth($linewidth)\","
382 |                  ." label=\""
383 |                  .$label."\", headlabel=\"".$headlabel
384 |                  ."\", taillabel=\"".$taillabel."\" ]";
385 |       $result .= ";\n";
386 | 
387 |     }
388 |   }
389 |   $result = $result . "\n}";
390 | 
391 |   return $result;
392 | }
393 | 
394 | function  xhprof_render_diff_image($xhprof_runs_impl, $run1, $run2,
395 |                                    $type, $threshold, $source) {
396 |   $total1;
397 |   $total2;
398 | 
399 |   $raw_data1 = $xhprof_runs_impl->get_run($run1, $source, $desc_unused);
400 |   $raw_data2 = $xhprof_runs_impl->get_run($run2, $source, $desc_unused);
401 | 
402 |   // init_metrics($raw_data1, null, null);
403 |   $children_table1 = xhprof_get_children_table($raw_data1);
404 |   $children_table2 = xhprof_get_children_table($raw_data2);
405 |   $symbol_tab1 = xhprof_compute_flat_info($raw_data1, $total1);
406 |   $symbol_tab2 = xhprof_compute_flat_info($raw_data2, $total2);
407 |   $run_delta = xhprof_compute_diff($raw_data1, $raw_data2);
408 |   $script = xhprof_generate_dot_script($run_delta, $threshold, $source,
409 |                                        null, null, true,
410 |                                        $symbol_tab1, $symbol_tab2);
411 |   $content = xhprof_generate_image_by_dot($script, $type);
412 | 
413 |   xhprof_generate_mime_header($type, strlen($content));
414 |   echo $content;
415 | }
416 | 
417 | /**
418 |  * Generate image content from phprof run id.
419 |  *
420 |  * @param object  $xhprof_runs_impl  An object that implements
421 |  *                                   the iXHProfRuns interface
422 |  * @param run_id, integer, the unique id for the phprof run, this is the
423 |  *                primary key for phprof database table.
424 |  * @param type, string, one of the supported image types. See also
425 |  *              $xhprof_legal_image_types.
426 |  * @param threshold, float, the threshold value [0,1). The functions in the
427 |  *                   raw_data whose exclusive wall times ratio are below the
428 |  *                   threshold will be filtered out and won't apprear in the
429 |  *                   generated image.
430 |  * @param func, string, the focus function.
431 |  * @returns, string, the DOT script to generate image.
432 |  *
433 |  * @author cjiang
434 |  */
435 | function xhprof_get_content_by_run($xhprof_runs_impl, $run_id, $type,
436 |                                    $threshold, $func, $source,
437 |                                    $critical_path) {
438 |   if (!$run_id)
439 |     return "";
440 | 
441 |   $raw_data = $xhprof_runs_impl->get_run($run_id, $source, $description);
442 |   if (!$raw_data) {
443 |     xhprof_error("Raw data is empty");
444 |     return "";
445 |   }
446 | 
447 |   $script = xhprof_generate_dot_script($raw_data, $threshold, $source,
448 |                                        $description, $func, $critical_path);
449 | 
450 |   $content = xhprof_generate_image_by_dot($script, $type);
451 |   return $content;
452 | }
453 | 
454 | /**
455 |  * Generate image from phprof run id and send it to client.
456 |  *
457 |  * @param object  $xhprof_runs_impl  An object that implements
458 |  *                                   the iXHProfRuns interface
459 |  * @param run_id, integer, the unique id for the phprof run, this is the
460 |  *                primary key for phprof database table.
461 |  * @param type, string, one of the supported image types. See also
462 |  *              $xhprof_legal_image_types.
463 |  * @param threshold, float, the threshold value [0,1). The functions in the
464 |  *                   raw_data whose exclusive wall times ratio are below the
465 |  *                   threshold will be filtered out and won't apprear in the
466 |  *                   generated image.
467 |  * @param func, string, the focus function.
468 |  * @param bool, does this run correspond to a PHProfLive run or a dev run?
469 |  * @author cjiang
470 |  */
471 | function xhprof_render_image($xhprof_runs_impl, $run_id, $type, $threshold,
472 |                              $func, $source, $critical_path) {
473 | 
474 |   $content = xhprof_get_content_by_run($xhprof_runs_impl, $run_id, $type,
475 |                                        $threshold,
476 |                                        $func, $source, $critical_path);
477 |   if (!$content) {
478 |     print "Error: either we can not find profile data for run_id ".$run_id
479 |           ." or the threshold ".$threshold." is too small or you do not"
480 |           ." have 'dot' image generation utility installed.";
481 |     exit();
482 |   }
483 | 
484 |   xhprof_generate_mime_header($type, strlen($content));
485 |   echo $content;
486 | }
487 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_lib/utils/xhprof_lib.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | //  Copyright (c) 2009 Facebook
  3 | //
  4 | //  Licensed under the Apache License, Version 2.0 (the "License");
  5 | //  you may not use this file except in compliance with the License.
  6 | //  You may obtain a copy of the License at
  7 | //
  8 | //      http://www.apache.org/licenses/LICENSE-2.0
  9 | //
 10 | //  Unless required by applicable law or agreed to in writing, software
 11 | //  distributed under the License is distributed on an "AS IS" BASIS,
 12 | //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | //  See the License for the specific language governing permissions and
 14 | //  limitations under the License.
 15 | //
 16 | 
 17 | //
 18 | // This file contains various XHProf library (utility) functions.
 19 | // Do not add any display specific code here.
 20 | //
 21 | 
 22 | function xhprof_error($message) {
 23 |   error_log($message);
 24 | }
 25 | 
 26 | /*
 27 |  * The list of possible metrics collected as part of XHProf that
 28 |  * require inclusive/exclusive handling while reporting.
 29 |  *
 30 |  * @author Kannan
 31 |  */
 32 | function xhprof_get_possible_metrics() {
 33 |  static $possible_metrics =
 34 |    array("wt" => array("Wall", "microsecs", "walltime"),
 35 |          "ut" => array("User", "microsecs", "user cpu time"),
 36 |          "st" => array("Sys", "microsecs", "system cpu time"),
 37 |          "cpu" => array("Cpu", "microsecs", "cpu time"),
 38 |          "mu" => array("MUse", "bytes", "memory usage"),
 39 |          "pmu" => array("PMUse", "bytes", "peak memory usage"),
 40 |          "samples" => array("Samples", "samples", "cpu time"));
 41 |  return $possible_metrics;
 42 | }
 43 | 
 44 | /**
 45 |  * Initialize the metrics we'll display based on the information
 46 |  * in the raw data.
 47 |  *
 48 |  * @author Kannan
 49 |  */
 50 | function init_metrics($xhprof_data, $rep_symbol, $sort, $diff_report = false) {
 51 |   global $stats;
 52 |   global $pc_stats;
 53 |   global $metrics;
 54 |   global $diff_mode;
 55 |   global $sortable_columns;
 56 |   global $sort_col;
 57 |   global $display_calls;
 58 | 
 59 |   $diff_mode = $diff_report;
 60 | 
 61 |   if (!empty($sort)) {
 62 |     if (array_key_exists($sort, $sortable_columns)) {
 63 |       $sort_col = $sort;
 64 |     } else {
 65 |       print("Invalid Sort Key $sort specified in URL");
 66 |     }
 67 |   }
 68 | 
 69 |   // For C++ profiler runs, walltime attribute isn't present.
 70 |   // In that case, use "samples" as the default sort column.
 71 |   if (!isset($xhprof_data["main()"]["wt"])) {
 72 | 
 73 |     if ($sort_col == "wt") {
 74 |       $sort_col = "samples";
 75 |     }
 76 | 
 77 |     // C++ profiler data doesn't have call counts.
 78 |     // ideally we should check to see if "ct" metric
 79 |     // is present for "main()". But currently "ct"
 80 |     // metric is artificially set to 1. So, relying
 81 |     // on absence of "wt" metric instead.
 82 |     $display_calls = false;
 83 |   } else {
 84 |     $display_calls = true;
 85 |   }
 86 | 
 87 |   // parent/child report doesn't support exclusive times yet.
 88 |   // So, change sort hyperlinks to closest fit.
 89 |   if (!empty($rep_symbol)) {
 90 |     $sort_col = str_replace("excl_", "", $sort_col);
 91 |   }
 92 | 
 93 |   if ($display_calls) {
 94 |     $stats = array("fn", "ct", "Calls%");
 95 |   } else {
 96 |     $stats = array("fn");
 97 |   }
 98 | 
 99 |   $pc_stats = $stats;
100 | 
101 |   $possible_metrics = xhprof_get_possible_metrics($xhprof_data);
102 |   foreach ($possible_metrics as $metric => $desc) {
103 |     if (isset($xhprof_data["main()"][$metric])) {
104 |       $metrics[] = $metric;
105 |       // flat (top-level reports): we can compute
106 |       // exclusive metrics reports as well.
107 |       $stats[] = $metric;
108 |       $stats[] = "I" . $desc[0] . "%";
109 |       $stats[] = "excl_" . $metric;
110 |       $stats[] = "E" . $desc[0] . "%";
111 | 
112 |       // parent/child report for a function: we can
113 |       // only breakdown inclusive times correctly.
114 |       $pc_stats[] = $metric;
115 |       $pc_stats[] = "I" . $desc[0] . "%";
116 |     }
117 |   }
118 | }
119 | 
120 | /*
121 |  * Get the list of metrics present in $xhprof_data as an array.
122 |  *
123 |  * @author Kannan
124 |  */
125 | function xhprof_get_metrics($xhprof_data) {
126 | 
127 |   // get list of valid metrics
128 |   $possible_metrics = xhprof_get_possible_metrics();
129 | 
130 |   // return those that are present in the raw data.
131 |   // We'll just look at the root of the subtree for this.
132 |   $metrics = array();
133 |   foreach ($possible_metrics as $metric => $desc) {
134 |     if (isset($xhprof_data["main()"][$metric])) {
135 |       $metrics[] = $metric;
136 |     }
137 |   }
138 | 
139 |   return $metrics;
140 | }
141 | 
142 | /**
143 |  * Takes a parent/child function name encoded as
144 |  * "a==>b" and returns array("a", "b").
145 |  *
146 |  * @author Kannan
147 |  */
148 | function xhprof_parse_parent_child($parent_child) {
149 |   $ret = explode("==>", $parent_child);
150 | 
151 |   // Return if both parent and child are set
152 |   if (isset($ret[1])) {
153 |     return $ret;
154 |   }
155 | 
156 |   return array(null, $ret[0]);
157 | }
158 | 
159 | /**
160 |  * Given parent & child function name, composes the key
161 |  * in the format present in the raw data.
162 |  *
163 |  * @author Kannan
164 |  */
165 | function xhprof_build_parent_child_key($parent, $child) {
166 |   if ($parent) {
167 |     return $parent . "==>" . $child;
168 |   } else {
169 |     return $child;
170 |   }
171 | }
172 | 
173 | 
174 | /**
175 |  * Checks if XHProf raw data appears to be valid and not corrupted.
176 |  *
177 |  *  @param   int    $run_id        Run id of run to be pruned.
178 |  *                                 [Used only for reporting errors.]
179 |  *  @param   array  $raw_data      XHProf raw data to be pruned
180 |  *                                 & validated.
181 |  *
182 |  *  @return  bool   true on success, false on failure
183 |  *
184 |  *  @author Kannan
185 |  */
186 | function xhprof_valid_run($run_id, $raw_data) {
187 | 
188 |   $main_info = $raw_data["main()"];
189 |   if (empty($main_info)) {
190 |     xhprof_error("XHProf: main() missing in raw data for Run ID: $run_id");
191 |     return false;
192 |   }
193 | 
194 |   // raw data should contain either wall time or samples information...
195 |   if (isset($main_info["wt"])) {
196 |     $metric = "wt";
197 |   } else if (isset($main_info["samples"])) {
198 |     $metric = "samples";
199 |   } else {
200 |     xhprof_error("XHProf: Wall Time information missing from Run ID: $run_id");
201 |     return false;
202 |   }
203 | 
204 |   foreach ($raw_data as $info) {
205 |     $val = $info[$metric];
206 | 
207 |     // basic sanity checks...
208 |     if ($val < 0) {
209 |       xhprof_error("XHProf: $metric should not be negative: Run ID $run_id"
210 |                    . serialize($info));
211 |       return false;
212 |     }
213 |     if ($val > (86400000000)) {
214 |       xhprof_error("XHProf: $metric > 1 day found in Run ID: $run_id "
215 |                    . serialize($info));
216 |       return false;
217 |     }
218 |   }
219 |   return true;
220 | }
221 | 
222 | 
223 | /**
224 |  * Return a trimmed version of the XHProf raw data. Note that the raw
225 |  * data contains one entry for each unique parent/child function
226 |  * combination.The trimmed version of raw data will only contain
227 |  * entries where either the parent or child function is in the list
228 |  * of $functions_to_keep.
229 |  *
230 |  * Note: Function main() is also always kept so that overall totals
231 |  * can still be obtained from the trimmed version.
232 |  *
233 |  * @param  array  XHProf raw data
234 |  * @param  array  array of function names
235 |  *
236 |  * @return array  Trimmed XHProf Report
237 |  *
238 |  * @author Kannan
239 |  */
240 | function xhprof_trim_run($raw_data, $functions_to_keep) {
241 | 
242 |   // convert list of functions to a hash with function as the key
243 |   $function_map = array_fill_keys($functions_to_keep, 1);
244 | 
245 |   // always keep main() as well so that overall totals can still
246 |   // be computed if need be.
247 |   $function_map['main()'] = 1;
248 | 
249 |   $new_raw_data = array();
250 |   foreach ($raw_data as $parent_child => $info) {
251 |     list($parent, $child) = xhprof_parse_parent_child($parent_child);
252 | 
253 |     if (isset($function_map[$parent]) || isset($function_map[$child])) {
254 |       $new_raw_data[$parent_child] = $info;
255 |     }
256 |   }
257 | 
258 |   return $new_raw_data;
259 | }
260 | 
261 | /**
262 |  * Takes raw XHProf data that was aggregated over "$num_runs" number
263 |  * of runs averages/nomalizes the data. Essentially the various metrics
264 |  * collected are divided by $num_runs.
265 |  *
266 |  * @author Kannan
267 |  */
268 | function xhprof_normalize_metrics($raw_data, $num_runs) {
269 | 
270 |   if (empty($raw_data) || ($num_runs == 0)) {
271 |     return $raw_data;
272 |   }
273 | 
274 |   $raw_data_total = array();
275 | 
276 |   if (isset($raw_data["==>main()"]) && isset($raw_data["main()"])) {
277 |     xhprof_error("XHProf Error: both ==>main() and main() set in raw data...");
278 |   }
279 | 
280 |   foreach ($raw_data as $parent_child => $info) {
281 |     foreach ($info as $metric => $value) {
282 |       $raw_data_total[$parent_child][$metric] = ($value / $num_runs);
283 |     }
284 |   }
285 | 
286 |   return $raw_data_total;
287 | }
288 | 
289 | 
290 | /**
291 |  * Get raw data corresponding to specified array of runs
292 |  * aggregated by certain weightage.
293 |  *
294 |  * Suppose you have run:5 corresponding to page1.php,
295 |  *                  run:6 corresponding to page2.php,
296 |  *             and  run:7 corresponding to page3.php
297 |  *
298 |  * and you want to accumulate these runs in a 2:4:1 ratio. You
299 |  * can do so by calling:
300 |  *
301 |  *     xhprof_aggregate_runs(array(5, 6, 7), array(2, 4, 1));
302 |  *
303 |  * The above will return raw data for the runs aggregated
304 |  * in 2:4:1 ratio.
305 |  *
306 |  *  @param object  $xhprof_runs_impl  An object that implements
307 |  *                                    the iXHProfRuns interface
308 |  *  @param  array  $runs            run ids of the XHProf runs..
309 |  *  @param  array  $wts             integral (ideally) weights for $runs
310 |  *  @param  string $source          source to fetch raw data for run from
311 |  *  @param  bool   $use_script_name If true, a fake edge from main() to
312 |  *                                  to __script::<scriptname> is introduced
313 |  *                                  in the raw data so that after aggregations
314 |  *                                  the script name is still preserved.
315 |  *
316 |  *  @return array  Return aggregated raw data
317 |  *
318 |  *  @author Kannan
319 |  */
320 | function xhprof_aggregate_runs($xhprof_runs_impl, $runs,
321 |                                $wts, $source="phprof",
322 |                                $use_script_name=false) {
323 | 
324 |   $raw_data_total = null;
325 |   $raw_data       = null;
326 |   $metrics        = array();
327 | 
328 |   $run_count = count($runs);
329 |   $wts_count = count($wts);
330 | 
331 |   if (($run_count == 0) ||
332 |       (($wts_count > 0) && ($run_count != $wts_count))) {
333 |     return array('description' => 'Invalid input..',
334 |                  'raw'  => null);
335 |   }
336 | 
337 |   $bad_runs = array();
338 |   foreach ($runs as $idx => $run_id) {
339 | 
340 |     $raw_data = $xhprof_runs_impl->get_run($run_id, $source, $description);
341 | 
342 |     // use the first run to derive what metrics to aggregate on.
343 |     if ($idx == 0) {
344 |       foreach ($raw_data["main()"] as $metric => $val) {
345 |         if ($metric != "pmu") {
346 |           // for now, just to keep data size small, skip "peak" memory usage
347 |           // data while aggregating.
348 |           // The "regular" memory usage data will still be tracked.
349 |           if (isset($val)) {
350 |             $metrics[] = $metric;
351 |           }
352 |         }
353 |       }
354 |     }
355 | 
356 |     if (!xhprof_valid_run($run_id, $raw_data)) {
357 |       $bad_runs[] = $run_id;
358 |       continue;
359 |     }
360 | 
361 |     if ($use_script_name) {
362 |       $page = $description;
363 | 
364 |       // create a fake function '__script::$page', and have and edge from
365 |       // main() to '__script::$page'. We will also need edges to transfer
366 |       // all edges originating from main() to now originate from
367 |       // '__script::$page' to all function called from main().
368 |       //
369 |       // We also weight main() ever so slightly higher so that
370 |       // it shows up above the new entry in reports sorted by
371 |       // inclusive metrics or call counts.
372 |       if ($page) {
373 |         foreach ($raw_data["main()"] as $metric => $val) {
374 |           $fake_edge[$metric] = $val;
375 |           $new_main[$metric]  = $val + 0.00001;
376 |         }
377 |         $raw_data["main()"] = $new_main;
378 |         $raw_data[xhprof_build_parent_child_key("main()",
379 |                                                 "__script::$page")]
380 |           = $fake_edge;
381 |       } else {
382 |         $use_script_name = false;
383 |       }
384 |     }
385 | 
386 |     // if no weights specified, use 1 as the default weightage..
387 |     $wt = ($wts_count == 0) ? 1 : $wts[$idx];
388 | 
389 |     // aggregate $raw_data into $raw_data_total with appropriate weight ($wt)
390 |     foreach ($raw_data as $parent_child => $info) {
391 |       if ($use_script_name) {
392 |         // if this is an old edge originating from main(), it now
393 |         // needs to be from '__script::$page'
394 |         if (substr($parent_child, 0, 9) == "main()==>") {
395 |           $child = substr($parent_child, 9);
396 |           // ignore the newly added edge from main()
397 |           if (substr($child, 0, 10) != "__script::") {
398 |             $parent_child = xhprof_build_parent_child_key("__script::$page",
399 |                                                           $child);
400 |           }
401 |         }
402 |       }
403 | 
404 |       if (!isset($raw_data_total[$parent_child])) {
405 |         foreach ($metrics as $metric) {
406 |           $raw_data_total[$parent_child][$metric] = ($wt * $info[$metric]);
407 |         }
408 |       } else {
409 |         foreach ($metrics as $metric) {
410 |           $raw_data_total[$parent_child][$metric] += ($wt * $info[$metric]);
411 |         }
412 |       }
413 |     }
414 |   }
415 | 
416 |   $runs_string = implode(",", $runs);
417 | 
418 |   if (isset($wts)) {
419 |     $wts_string  = "in the ratio (" . implode(":", $wts) . ")";
420 |     $normalization_count = array_sum($wts);
421 |   } else {
422 |     $wts_string = "";
423 |     $normalization_count = $run_count;
424 |   }
425 | 
426 |   $run_count = $run_count - count($bad_runs);
427 | 
428 |   $data['description'] = "Aggregated Report for $run_count runs: ".
429 |                          "$runs_string $wts_string\n";
430 |   $data['raw'] = xhprof_normalize_metrics($raw_data_total,
431 |                                           $normalization_count);
432 |   $data['bad_runs'] = $bad_runs;
433 | 
434 |   return $data;
435 | }
436 | 
437 | 
438 | /**
439 |  * Analyze hierarchical raw data, and compute per-function (flat)
440 |  * inclusive and exclusive metrics.
441 |  *
442 |  * Also, store overall totals in the 2nd argument.
443 |  *
444 |  * @param  array $raw_data          XHProf format raw profiler data.
445 |  * @param  array &$overall_totals   OUT argument for returning
446 |  *                                  overall totals for various
447 |  *                                  metrics.
448 |  * @return array Returns a map from function name to its
449 |  *               call count and inclusive & exclusive metrics
450 |  *               (such as wall time, etc.).
451 |  *
452 |  * @author Kannan Muthukkaruppan
453 |  */
454 | function xhprof_compute_flat_info($raw_data, &$overall_totals) {
455 | 
456 |   global $display_calls;
457 | 
458 |   $metrics = xhprof_get_metrics($raw_data);
459 | 
460 |   $overall_totals = array("ct" => 0,
461 |                            "wt" => 0,
462 |                            "ut" => 0,
463 |                            "st" => 0,
464 |                            "cpu" => 0,
465 |                            "mu" => 0,
466 |                            "pmu" => 0,
467 |                            "samples" => 0
468 |                            );
469 | 
470 |   // compute inclusive times for each function
471 |   $symbol_tab = xhprof_compute_inclusive_times($raw_data);
472 | 
473 |   /* total metric value is the metric value for "main()" */
474 |   foreach ($metrics as $metric) {
475 |     $overall_totals[$metric] = $symbol_tab["main()"][$metric];
476 |   }
477 | 
478 |   /*
479 |    * initialize exclusive (self) metric value to inclusive metric value
480 |    * to start with.
481 |    * In the same pass, also add up the total number of function calls.
482 |    */
483 |   foreach ($symbol_tab as $symbol => $info) {
484 |     foreach ($metrics as $metric) {
485 |       $symbol_tab[$symbol]["excl_" . $metric] = $symbol_tab[$symbol][$metric];
486 |     }
487 |     if ($display_calls) {
488 |       /* keep track of total number of calls */
489 |       $overall_totals["ct"] += $info["ct"];
490 |     }
491 |   }
492 | 
493 |   /* adjust exclusive times by deducting inclusive time of children */
494 |   foreach ($raw_data as $parent_child => $info) {
495 |     list($parent, $child) = xhprof_parse_parent_child($parent_child);
496 | 
497 |     if ($parent) {
498 |       foreach ($metrics as $metric) {
499 |         // make sure the parent exists hasn't been pruned.
500 |         if (isset($symbol_tab[$parent])) {
501 |           $symbol_tab[$parent]["excl_" . $metric] -= $info[$metric];
502 |         }
503 |       }
504 |     }
505 |   }
506 | 
507 |   return $symbol_tab;
508 | }
509 | 
510 | /**
511 |  * Hierarchical diff:
512 |  * Compute and return difference of two call graphs: Run2 - Run1.
513 |  *
514 |  * @author Kannan
515 |  */
516 | function xhprof_compute_diff($xhprof_data1, $xhprof_data2) {
517 |   global $display_calls;
518 | 
519 |   // use the second run to decide what metrics we will do the diff on
520 |   $metrics = xhprof_get_metrics($xhprof_data2);
521 | 
522 |   $xhprof_delta = $xhprof_data2;
523 | 
524 |   foreach ($xhprof_data1 as $parent_child => $info) {
525 | 
526 |     if (!isset($xhprof_delta[$parent_child])) {
527 | 
528 |       // this pc combination was not present in run1;
529 |       // initialize all values to zero.
530 |       if ($display_calls) {
531 |         $xhprof_delta[$parent_child] = array("ct" => 0);
532 |       } else {
533 |         $xhprof_delta[$parent_child] = array();
534 |       }
535 |       foreach ($metrics as $metric) {
536 |         $xhprof_delta[$parent_child][$metric] = 0;
537 |       }
538 |     }
539 | 
540 |     if ($display_calls) {
541 |       $xhprof_delta[$parent_child]["ct"] -= $info["ct"];
542 |     }
543 | 
544 |     foreach ($metrics as $metric) {
545 |       $xhprof_delta[$parent_child][$metric] -= $info[$metric];
546 |     }
547 |   }
548 | 
549 |   return $xhprof_delta;
550 | }
551 | 
552 | 
553 | /**
554 |  * Compute inclusive metrics for function. This code was factored out
555 |  * of xhprof_compute_flat_info().
556 |  *
557 |  * The raw data contains inclusive metrics of a function for each
558 |  * unique parent function it is called from. The total inclusive metrics
559 |  * for a function is therefore the sum of inclusive metrics for the
560 |  * function across all parents.
561 |  *
562 |  * @return array  Returns a map of function name to total (across all parents)
563 |  *                inclusive metrics for the function.
564 |  *
565 |  * @author Kannan
566 |  */
567 | function xhprof_compute_inclusive_times($raw_data) {
568 |   global $display_calls;
569 | 
570 |   $metrics = xhprof_get_metrics($raw_data);
571 | 
572 |   $symbol_tab = array();
573 | 
574 |   /*
575 |    * First compute inclusive time for each function and total
576 |    * call count for each function across all parents the
577 |    * function is called from.
578 |    */
579 |   foreach ($raw_data as $parent_child => $info) {
580 | 
581 |     list($parent, $child) = xhprof_parse_parent_child($parent_child);
582 | 
583 |     if ($parent == $child) {
584 |       /*
585 |        * XHProf PHP extension should never trigger this situation any more.
586 |        * Recursion is handled in the XHProf PHP extension by giving nested
587 |        * calls a unique recursion-depth appended name (for example, foo@1).
588 |        */
589 |       xhprof_error("Error in Raw Data: parent & child are both: $parent");
590 |       return;
591 |     }
592 | 
593 |     if (!isset($symbol_tab[$child])) {
594 | 
595 |       if ($display_calls) {
596 |         $symbol_tab[$child] = array("ct" => $info["ct"]);
597 |       } else {
598 |         $symbol_tab[$child] = array();
599 |       }
600 |       foreach ($metrics as $metric) {
601 |         $symbol_tab[$child][$metric] = $info[$metric];
602 |       }
603 |     } else {
604 |       if ($display_calls) {
605 |         /* increment call count for this child */
606 |         $symbol_tab[$child]["ct"] += $info["ct"];
607 |       }
608 | 
609 |       /* update inclusive times/metric for this child  */
610 |       foreach ($metrics as $metric) {
611 |         $symbol_tab[$child][$metric] += $info[$metric];
612 |       }
613 |     }
614 |   }
615 | 
616 |   return $symbol_tab;
617 | }
618 | 
619 | 
620 | /*
621 |  * Prunes XHProf raw data:
622 |  *
623 |  * Any node whose inclusive walltime accounts for less than $prune_percent
624 |  * of total walltime is pruned. [It is possible that a child function isn't
625 |  * pruned, but one or more of its parents get pruned. In such cases, when
626 |  * viewing the child function's hierarchical information, the cost due to
627 |  * the pruned parent(s) will be attributed to a special function/symbol
628 |  * "__pruned__()".]
629 |  *
630 |  *  @param   array  $raw_data      XHProf raw data to be pruned & validated.
631 |  *  @param   double $prune_percent Any edges that account for less than
632 |  *                                 $prune_percent of time will be pruned
633 |  *                                 from the raw data.
634 |  *
635 |  *  @return  array  Returns the pruned raw data.
636 |  *
637 |  *  @author Kannan
638 |  */
639 | function xhprof_prune_run($raw_data, $prune_percent) {
640 | 
641 |   $main_info = $raw_data["main()"];
642 |   if (empty($main_info)) {
643 |     xhprof_error("XHProf: main() missing in raw data");
644 |     return false;
645 |   }
646 | 
647 |   // raw data should contain either wall time or samples information...
648 |   if (isset($main_info["wt"])) {
649 |     $prune_metric = "wt";
650 |   } else if (isset($main_info["samples"])) {
651 |     $prune_metric = "samples";
652 |   } else {
653 |     xhprof_error("XHProf: for main() we must have either wt "
654 |                  ."or samples attribute set");
655 |     return false;
656 |   }
657 | 
658 |   // determine the metrics present in the raw data..
659 |   $metrics = array();
660 |   foreach ($main_info as $metric => $val) {
661 |     if (isset($val)) {
662 |       $metrics[] = $metric;
663 |     }
664 |   }
665 | 
666 |   $prune_threshold = (($main_info[$prune_metric] * $prune_percent) / 100.0);
667 | 
668 |   init_metrics($raw_data, null, null, false);
669 |   $flat_info = xhprof_compute_inclusive_times($raw_data);
670 | 
671 |   foreach ($raw_data as $parent_child => $info) {
672 | 
673 |     list($parent, $child) = xhprof_parse_parent_child($parent_child);
674 | 
675 |     // is this child's overall total from all parents less than threshold?
676 |     if ($flat_info[$child][$prune_metric] < $prune_threshold) {
677 |       unset($raw_data[$parent_child]); // prune the edge
678 |     } else if ($parent &&
679 |                ($parent != "__pruned__()") &&
680 |                ($flat_info[$parent][$prune_metric] < $prune_threshold)) {
681 | 
682 |       // Parent's overall inclusive metric is less than a threshold.
683 |       // All edges to the parent node will get nuked, and this child will
684 |       // be a dangling child.
685 |       // So instead change its parent to be a special function __pruned__().
686 |       $pruned_edge = xhprof_build_parent_child_key("__pruned__()", $child);
687 | 
688 |       if (isset($raw_data[$pruned_edge])) {
689 |         foreach ($metrics as $metric) {
690 |           $raw_data[$pruned_edge][$metric]+=$raw_data[$parent_child][$metric];
691 |         }
692 |       } else {
693 |         $raw_data[$pruned_edge] = $raw_data[$parent_child];
694 |       }
695 | 
696 |       unset($raw_data[$parent_child]); // prune the edge
697 |     }
698 |   }
699 | 
700 |   return $raw_data;
701 | }
702 | 
703 | 
704 | /**
705 |  * Set one key in an array and return the array
706 |  *
707 |  * @author Kannan
708 |  */
709 | function xhprof_array_set($arr, $k, $v) {
710 |   $arr[$k] = $v;
711 |   return $arr;
712 | }
713 | 
714 | /**
715 |  * Removes/unsets one key in an array and return the array
716 |  *
717 |  * @author Kannan
718 |  */
719 | function xhprof_array_unset($arr, $k) {
720 |   unset($arr[$k]);
721 |   return $arr;
722 | }
723 | 
724 | /**
725 |  * Type definitions for URL params
726 |  */
727 | define('XHPROF_STRING_PARAM', 1);
728 | define('XHPROF_UINT_PARAM',   2);
729 | define('XHPROF_FLOAT_PARAM',  3);
730 | define('XHPROF_BOOL_PARAM',   4);
731 | 
732 | 
733 | /**
734 |  * Internal helper function used by various
735 |  * xhprof_get_param* flavors for various
736 |  * types of parameters.
737 |  *
738 |  * @param string   name of the URL query string param
739 |  *
740 |  * @author Kannan
741 |  */
742 | function xhprof_get_param_helper($param) {
743 |   $val = null;
744 |   if (isset($_GET[$param]))
745 |     $val = $_GET[$param];
746 |   else if (isset($_POST[$param])) {
747 |     $val = $_POST[$param];
748 |   }
749 |   return $val;
750 | }
751 | 
752 | /**
753 |  * Extracts value for string param $param from query
754 |  * string. If param is not specified, return the
755 |  * $default value.
756 |  *
757 |  * @author Kannan
758 |  */
759 | function xhprof_get_string_param($param, $default = '') {
760 |   $val = xhprof_get_param_helper($param);
761 | 
762 |   if ($val === null)
763 |     return $default;
764 | 
765 |   return $val;
766 | }
767 | 
768 | /**
769 |  * Extracts value for unsigned integer param $param from
770 |  * query string. If param is not specified, return the
771 |  * $default value.
772 |  *
773 |  * If value is not a valid unsigned integer, logs error
774 |  * and returns null.
775 |  *
776 |  * @author Kannan
777 |  */
778 | function xhprof_get_uint_param($param, $default = 0) {
779 |   $val = xhprof_get_param_helper($param);
780 | 
781 |   if ($val === null)
782 |     $val = $default;
783 | 
784 |   // trim leading/trailing whitespace
785 |   $val = trim($val);
786 | 
787 |   // if it only contains digits, then ok..
788 |   if (ctype_digit($val)) {
789 |     return $val;
790 |   }
791 | 
792 |   xhprof_error("$param is $val. It must be an unsigned integer.");
793 |   return null;
794 | }
795 | 
796 | 
797 | /**
798 |  * Extracts value for a float param $param from
799 |  * query string. If param is not specified, return
800 |  * the $default value.
801 |  *
802 |  * If value is not a valid unsigned integer, logs error
803 |  * and returns null.
804 |  *
805 |  * @author Kannan
806 |  */
807 | function xhprof_get_float_param($param, $default = 0) {
808 |   $val = xhprof_get_param_helper($param);
809 | 
810 |   if ($val === null)
811 |     $val = $default;
812 | 
813 |   // trim leading/trailing whitespace
814 |   $val = trim($val);
815 | 
816 |   // TBD: confirm the value is indeed a float.
817 |   if (true) // for now..
818 |     return (float)$val;
819 | 
820 |   xhprof_error("$param is $val. It must be a float.");
821 |   return null;
822 | }
823 | 
824 | /**
825 |  * Extracts value for a boolean param $param from
826 |  * query string. If param is not specified, return
827 |  * the $default value.
828 |  *
829 |  * If value is not a valid unsigned integer, logs error
830 |  * and returns null.
831 |  *
832 |  * @author Kannan
833 |  */
834 | function xhprof_get_bool_param($param, $default = false) {
835 |   $val = xhprof_get_param_helper($param);
836 | 
837 |   if ($val === null)
838 |     $val = $default;
839 | 
840 |   // trim leading/trailing whitespace
841 |   $val = trim($val);
842 | 
843 |   switch (strtolower($val)) {
844 |   case '0':
845 |   case '1':
846 |     $val = (bool)$val;
847 |     break;
848 |   case 'true':
849 |   case 'on':
850 |   case 'yes':
851 |     $val = true;
852 |     break;
853 |   case 'false':
854 |   case 'off':
855 |   case 'no':
856 |     $val = false;
857 |     break;
858 |   default:
859 |     xhprof_error("$param is $val. It must be a valid boolean string.");
860 |     return null;
861 |   }
862 | 
863 |   return $val;
864 | 
865 | }
866 | 
867 | /**
868 |  * Initialize params from URL query string. The function
869 |  * creates globals variables for each of the params
870 |  * and if the URL query string doesn't specify a particular
871 |  * param initializes them with the corresponding default
872 |  * value specified in the input.
873 |  *
874 |  * @params array $params An array whose keys are the names
875 |  *                       of URL params who value needs to
876 |  *                       be retrieved from the URL query
877 |  *                       string. PHP globals are created
878 |  *                       with these names. The value is
879 |  *                       itself an array with 2-elems (the
880 |  *                       param type, and its default value).
881 |  *                       If a param is not specified in the
882 |  *                       query string the default value is
883 |  *                       used.
884 |  * @author Kannan
885 |  */
886 | function xhprof_param_init($params) {
887 |   /* Create variables specified in $params keys, init defaults */
888 |   foreach ($params as $k => $v) {
889 |     switch ($v[0]) {
890 |     case XHPROF_STRING_PARAM:
891 |       $p = xhprof_get_string_param($k, $v[1]);
892 |       break;
893 |     case XHPROF_UINT_PARAM:
894 |       $p = xhprof_get_uint_param($k, $v[1]);
895 |       break;
896 |     case XHPROF_FLOAT_PARAM:
897 |       $p = xhprof_get_float_param($k, $v[1]);
898 |       break;
899 |     case XHPROF_BOOL_PARAM:
900 |       $p = xhprof_get_bool_param($k, $v[1]);
901 |       break;
902 |     default:
903 |       xhprof_error("Invalid param type passed to xhprof_param_init: "
904 |                    . $v[0]);
905 |       exit();
906 |     }
907 | 
908 |     // create a global variable using the parameter name.
909 |     $GLOBALS[$k] = $p;
910 |   }
911 | }
912 | 
913 | 
914 | /**
915 |  * Given a partial query string $q return matching function names in
916 |  * specified XHProf run. This is used for the type ahead function
917 |  * selector.
918 |  *
919 |  * @author Kannan
920 |  */
921 | function xhprof_get_matching_functions($q, $xhprof_data) {
922 | 
923 |   $matches = array();
924 | 
925 |   foreach ($xhprof_data as $parent_child => $info) {
926 |     list($parent, $child) = xhprof_parse_parent_child($parent_child);
927 |     if (stripos($parent, $q) !== false) {
928 |       $matches[$parent] = 1;
929 |     }
930 |     if (stripos($child, $q) !== false) {
931 |       $matches[$child] = 1;
932 |     }
933 |   }
934 | 
935 |   $res = array_keys($matches);
936 | 
937 |   // sort it so the answers are in some reliable order...
938 |   asort($res);
939 | 
940 |   return ($res);
941 | }
942 | 
943 | 


--------------------------------------------------------------------------------
/public/xhprof/xhprof_lib/utils/xhprof_runs.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | //
  3 | //  Copyright (c) 2009 Facebook
  4 | //
  5 | //  Licensed under the Apache License, Version 2.0 (the "License");
  6 | //  you may not use this file except in compliance with the License.
  7 | //  You may obtain a copy of the License at
  8 | //
  9 | //      http://www.apache.org/licenses/LICENSE-2.0
 10 | //
 11 | //  Unless required by applicable law or agreed to in writing, software
 12 | //  distributed under the License is distributed on an "AS IS" BASIS,
 13 | //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14 | //  See the License for the specific language governing permissions and
 15 | //  limitations under the License.
 16 | //
 17 | 
 18 | //
 19 | // This file defines the interface iXHProfRuns and also provides a default
 20 | // implementation of the interface (class XHProfRuns).
 21 | //
 22 | 
 23 | /**
 24 |  * iXHProfRuns interface for getting/saving a XHProf run.
 25 |  *
 26 |  * Clients can either use the default implementation,
 27 |  * namely XHProfRuns_Default, of this interface or define
 28 |  * their own implementation.
 29 |  *
 30 |  * @author Kannan
 31 |  */
 32 | interface iXHProfRuns {
 33 | 
 34 |   /**
 35 |    * Returns XHProf data given a run id ($run) of a given
 36 |    * type ($type).
 37 |    *
 38 |    * Also, a brief description of the run is returned via the
 39 |    * $run_desc out parameter.
 40 |    */
 41 |   public function get_run($run_id, $type, &$run_desc);
 42 | 
 43 |   /**
 44 |    * Save XHProf data for a profiler run of specified type
 45 |    * ($type).
 46 |    *
 47 |    * The caller may optionally pass in run_id (which they
 48 |    * promise to be unique). If a run_id is not passed in,
 49 |    * the implementation of this method must generated a
 50 |    * unique run id for this saved XHProf run.
 51 |    *
 52 |    * Returns the run id for the saved XHProf run.
 53 |    *
 54 |    */
 55 |   public function save_run($xhprof_data, $type, $run_id = null);
 56 | }
 57 | 
 58 | 
 59 | /**
 60 |  * XHProfRuns_Default is the default implementation of the
 61 |  * iXHProfRuns interface for saving/fetching XHProf runs.
 62 |  *
 63 |  * It stores/retrieves runs to/from a filesystem directory
 64 |  * specified by the "xhprof.output_dir" ini parameter.
 65 |  *
 66 |  * @author Kannan
 67 |  */
 68 | class XHProfRuns_Default implements iXHProfRuns {
 69 | 
 70 |   private $dir = '';
 71 |   private $suffix = 'xhprof';
 72 | 
 73 |   private function gen_run_id($type) {
 74 |     return uniqid();
 75 |   }
 76 | 
 77 |   private function file_name($run_id, $type) {
 78 | 
 79 |     $file = "$run_id.$type." . $this->suffix;
 80 | 
 81 |     if (!empty($this->dir)) {
 82 |       $file = $this->dir . "/" . $file;
 83 |     }
 84 |     return $file;
 85 |   }
 86 | 
 87 |   public function __construct($dir = null) {
 88 | 
 89 |     // if user hasn't passed a directory location,
 90 |     // we use the xhprof.output_dir ini setting
 91 |     // if specified, else we default to the directory
 92 |     // in which the error_log file resides.
 93 | 
 94 |     if (empty($dir)) {
 95 |       $dir = ini_get("xhprof.output_dir");
 96 |       if (empty($dir)) {
 97 | 
 98 |         // some default that at least works on unix...
 99 |         $dir = "/tmp";
100 | 
101 |         xhprof_error("Warning: Must specify directory location for XHProf runs. ".
102 |                      "Trying {$dir} as default. You can either pass the " .
103 |                      "directory location as an argument to the constructor ".
104 |                      "for XHProfRuns_Default() or set xhprof.output_dir ".
105 |                      "ini param.");
106 |       }
107 |     }
108 |     $this->dir = $dir;
109 |   }
110 | 
111 |   public function get_run($run_id, $type, &$run_desc) {
112 |     $file_name = $this->file_name($run_id, $type);
113 | 
114 |     if (!file_exists($file_name)) {
115 |       xhprof_error("Could not find file $file_name");
116 |       $run_desc = "Invalid Run Id = $run_id";
117 |       return null;
118 |     }
119 | 
120 |     $contents = file_get_contents($file_name);
121 |     $run_desc = "XHProf Run (Namespace=$type)";
122 |     return unserialize($contents);
123 |   }
124 | 
125 |   public function save_run($xhprof_data, $type, $run_id = null) {
126 | 
127 |     // Use PHP serialize function to store the XHProf's
128 |     // raw profiler data.
129 |     $xhprof_data = serialize($xhprof_data);
130 | 
131 |     if ($run_id === null) {
132 |       $run_id = $this->gen_run_id($type);
133 |     }
134 | 
135 |     $file_name = $this->file_name($run_id, $type);
136 |     $file = fopen($file_name, 'w');
137 | 
138 |     if ($file) {
139 |       fwrite($file, $xhprof_data);
140 |       fclose($file);
141 |     } else {
142 |       xhprof_error("Could not open $file_name\n");
143 |     }
144 | 
145 |     // echo "Saved run in {$file_name}.\nRun id = {$run_id}.\n";
146 |     return $run_id;
147 |   }
148 | 
149 |   function list_runs() {
150 |     if (is_dir($this->dir)) {
151 |         echo "<hr/>Existing runs:\n<ul>\n";
152 |         $files = glob("{$this->dir}/*.{$this->suffix}");
153 |         usort($files, create_function('$a,$b', 'return filemtime($b) - filemtime($a);'));
154 |         foreach ($files as $file) {
155 |             list($run,$source) = explode('.', basename($file));
156 |             echo '<li><a href="' . htmlentities($_SERVER['SCRIPT_NAME'])
157 |                 . '?run=' . htmlentities($run) . '&source='
158 |                 . htmlentities($source) . '">'
159 |                 . htmlentities(basename($file)) . "</a><small> "
160 |                 . date("Y-m-d H:i:s", filemtime($file)) . "</small></li>\n";
161 |         }
162 |         echo "</ul>\n";
163 |     }
164 |   }
165 | }
166 | 


--------------------------------------------------------------------------------
/storage/cache/.gitignore:
--------------------------------------------------------------------------------
1 | # ignore all except .gitignore file
2 | *
3 | !.gitignore


--------------------------------------------------------------------------------
/storage/logs/.gitignore:
--------------------------------------------------------------------------------
1 | # ignore all except .gitignore file
2 | *
3 | !.gitignore


--------------------------------------------------------------------------------