1: <?php namespace Laravel\Profiling;
  2: 
  3: use Laravel\View;
  4: use Laravel\File;
  5: use Laravel\Event;
  6: use Laravel\Config;
  7: use Laravel\Request;
  8: use Laravel\Database;
  9: 
 10: class Profiler {
 11: 
 12:     /**
 13:      * An array of the recorded Profiler data.
 14:      *
 15:      * @var array
 16:      */
 17:     protected static $data = array('queries' => array(), 'logs' => array(), 'timers' => array());
 18:     
 19:     /**
 20:      * Get the rendered contents of the Profiler.
 21:      *
 22:      * @param  Response  $response
 23:      * @return string
 24:      */
 25:     public static function render($response)
 26:     {
 27:         // We only want to send the profiler toolbar if the request is not an AJAX
 28:         // request, as sending it on AJAX requests could mess up JSON driven API
 29:         // type applications, so we will not send anything in those scenarios.
 30:         if ( ! Request::ajax() and Config::get('application.profiler') )
 31:         {
 32:             static::$data['memory'] = get_file_size(memory_get_usage(true));
 33:             static::$data['memory_peak'] = get_file_size(memory_get_peak_usage(true));
 34:             static::$data['time'] = number_format((microtime(true) - LARAVEL_START) * 1000, 2);
 35:             foreach ( static::$data['timers'] as &$timer)
 36:             {
 37:                 $timer['running_time'] = number_format((microtime(true) - $timer['start'] ) * 1000, 2);
 38:             }
 39: 
 40:             return render('path: '.__DIR__.'/template'.BLADE_EXT, static::$data);
 41:         }
 42:     }
 43: 
 44:     /**
 45:      * Allow a callback to be timed.
 46:      *
 47:      * @param closure $func
 48:      * @param string $name
 49:      * @return void
 50:      */
 51:     public static function time( $func, $name = 'default_func_timer' )
 52:     {
 53:         // First measure the runtime of the func
 54:         $start = microtime(true);
 55:         $func();
 56:         $end = microtime(true);
 57: 
 58:         // Check to see if a timer by that name exists
 59:         if (isset(static::$data['timers'][$name]))
 60:         {
 61:             $name = $name.uniqid();
 62:         }
 63:         
 64:         // Push the time into the timers array for display
 65:         static::$data['timers'][$name]['start'] = $start;
 66:         static::$data['timers'][$name]['end'] = $end;
 67:         static::$data['timers'][$name]['time'] = number_format(($end - $start) * 1000, 2);
 68:     }
 69: 
 70:     /**
 71:      *  Start, or add a tick to a timer.
 72:      *
 73:      * @param string $name
 74:      * @return void
 75:      */
 76:     public static function tick($name = 'default_timer', $callback = null)
 77:     {
 78:         $name = trim($name);
 79:         if (empty($name)) $name = 'default_timer';
 80: 
 81:         // Is this a brand new tick?
 82:         if (isset(static::$data['timers'][$name]))
 83:         {
 84:             $current_timer = static::$data['timers'][$name];
 85:             $ticks = count($current_timer['ticks']);
 86: 
 87:             // Initialize the new time for the tick
 88:             $new_tick = array();
 89:             $mt = microtime(true);
 90:             $new_tick['raw_time'] = $mt - $current_timer['start'];
 91:             $new_tick['time'] = number_format(($mt - $current_timer['start']) * 1000, 2);
 92: 
 93:             // Use either the start time or the last tick for the diff
 94:             if ($ticks > 0)
 95:             {
 96:                 $last_tick = $current_timer['ticks'][$ticks- 1]['raw_time'];
 97:                 $new_tick['diff'] = number_format(($new_tick['raw_time'] - $last_tick) * 1000, 2);
 98:             }
 99:             else
100:             {
101:                 $new_tick['diff'] = $new_tick['time'];
102:             }
103: 
104:             // Add the new tick to the stack of them
105:             static::$data['timers'][$name]['ticks'][] = $new_tick;
106:         }
107:         else
108:         {
109:             // Initialize a start time on the first tick
110:             static::$data['timers'][$name]['start'] = microtime(true);
111:             static::$data['timers'][$name]['ticks'] = array();
112:         }
113: 
114:         // Run the callback for this tick if it's specified
115:         if ( ! is_null($callback) and is_callable($callback))
116:         {
117:             // After we've ticked, call the callback function
118:             call_user_func_array($callback, array(
119:                 static::$data['timers'][$name]
120:             ));
121:         }
122:     }
123: 
124:     /**
125:      * Add a log entry to the log entries array.
126:      *
127:      * @param  string  $type
128:      * @param  string  $message
129:      * @return void
130:      */
131:     public static function log($type, $message)
132:     {
133:         static::$data['logs'][] = array($type, $message);
134:     }
135: 
136:     /**
137:      * Add a performed SQL query to the Profiler.
138:      *
139:      * @param   string  $sql
140:      * @param   array   $bindings
141:      * @param   float   $time
142:      * @return  void
143:      */
144:     public static function query($sql, $bindings, $time)
145:     {
146:         foreach ($bindings as $binding)
147:         {
148:             $binding = Database::escape($binding);
149:             
150:             $sql = preg_replace('/\?/', $binding, $sql, 1);
151:             $sql = htmlspecialchars($sql, ENT_QUOTES, 'UTF-8', false);
152:         }
153: 
154:         static::$data['queries'][] = array($sql, $time);
155:     }
156: 
157:     /**
158:      * Attach the Profiler's event listeners.
159:      *
160:      * @return void
161:      */
162:     public static function attach()
163:     {
164:         // First we'll attach to the query and log events. These allow us to catch
165:         // all of the SQL queries and log messages that come through Laravel,
166:         // and we will pass them onto the Profiler for simple storage.
167:         Event::listen('laravel.log', function($type, $message)
168:         {
169:             Profiler::log($type, $message);
170:         });
171: 
172:         Event::listen('laravel.query', function($sql, $bindings, $time)
173:         {
174:             Profiler::query($sql, $bindings, $time);            
175:         });
176: 
177:         // We'll attach the profiler to the "done" event so that we can easily
178:         // attach the profiler output to the end of the output sent to the
179:         // browser. This will display the profiler's nice toolbar.
180:         Event::listen('laravel.done', function($response)
181:         {
182:             echo Profiler::render($response);
183:         });
184:     }
185: 
186: }
187: