Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\DataSource;

use Clockwork\Helpers\Serializer;
use Clockwork\Helpers\StackTrace;
use Clockwork\Request\Request;
use Clockwork\Support\Laravel\Eloquent\ResolveModelLegacyScope;
use Clockwork\Support\Laravel\Eloquent\ResolveModelScope;

use Illuminate\Database\ConnectionResolverInterface;
use Illuminate\Contracts\Events\Dispatcher as EventDispatcher;

// Data source for Eloquent (Laravel ORM), provides database queries, stats, model actions and counts
class EloquentDataSource extends DataSource
{
        use Concerns\EloquentDetectDuplicateQueries;

        // Database manager instance
        protected $databaseManager;

        // Event dispatcher instance
        protected $eventDispatcher;

        // Array of collected queries
        protected $queries = [];

        // Query counts by type
        protected $count = [
                'total' => 0, 'slow' => 0, 'select' => 0, 'insert' => 0, 'update' => 0, 'delete' => 0, 'other' => 0
        ];

        // Collected models actions
        protected $modelsActions = [];

        // Model action counts by model, eg. [ 'retrieved' => [ User::class => 1 ] ]
        protected $modelsCount = [
                'retrieved' => [], 'created' => [], 'updated' => [], 'deleted' => []
        ];

        // Whether we are collecting database queries or stats only
        protected $collectQueries = true;

        // Whether we are collecting models actions or stats only
        protected $collectModelsActions = true;

        // Whether we are collecting retrieved models as well when collecting models actions
        protected $collectModelsRetrieved = false;

        // Query execution time threshold in ms after which the query is marked as slow
        protected $slowThreshold;

        // Enable duplicate queries detection
        protected $detectDuplicateQueries = false;

        // Model name to associate with the next executed query, used to map queries to models
        public $nextQueryModel;

        // Create a new data source instance, takes a database manager, an event dispatcher as arguments and additional
        // options as arguments
        public function __construct(ConnectionResolverInterface $databaseManager, EventDispatcher $eventDispatcher, $collectQueries = true, $slowThreshold = null, $slowOnly = false, $detectDuplicateQueries = false, $collectModelsActions = true, $collectModelsRetrieved = false)
        {
                $this->databaseManager = $databaseManager;
                $this->eventDispatcher = $eventDispatcher;

                $this->collectQueries         = $collectQueries;
                $this->slowThreshold          = $slowThreshold;
                $this->detectDuplicateQueries = $detectDuplicateQueries;
                $this->collectModelsActions   = $collectModelsActions;
                $this->collectModelsRetrieved = $collectModelsRetrieved;

                if ($slowOnly) $this->addFilter(function ($query) { return $query['duration'] > $this->slowThreshold; });
        }

        // Adds ran database queries, query counts, models actions and models counts to the request
        public function resolve(Request $request)
        {
                $request->databaseQueries = array_merge($request->databaseQueries, $this->queries);

                $request->databaseQueriesCount += $this->count['total'];
                $request->databaseSlowQueries  += $this->count['slow'];
                $request->databaseSelects      += $this->count['select'];
                $request->databaseInserts      += $this->count['insert'];
                $request->databaseUpdates      += $this->count['update'];
                $request->databaseDeletes      += $this->count['delete'];
                $request->databaseOthers       += $this->count['other'];

                $request->modelsActions = array_merge($request->modelsActions, $this->modelsActions);

                $request->modelsRetrieved = $this->modelsCount['retrieved'];
                $request->modelsCreated   = $this->modelsCount['created'];
                $request->modelsUpdated   = $this->modelsCount['updated'];
                $request->modelsDeleted   = $this->modelsCount['deleted'];

                $this->appendDuplicateQueriesWarnings($request);

                return $request;
        }

        // Reset the data source to an empty state, clearing any collected data
        public function reset()
        {
                $this->queries = [];
                $this->count = [
                        'total' => 0, 'slow' => 0, 'select' => 0, 'insert' => 0, 'update' => 0, 'delete' => 0, 'other' => 0
                ];

                $this->modelsActions = [];
                $this->modelsCount = [
                        'retrieved' => [], 'created' => [], 'updated' => [], 'deleted' => []
                ];

                $this->nextQueryModel = null;
        }

        // Start listening to Eloquent events
        public function listenToEvents()
        {
                if ($scope = $this->getModelResolvingScope()) {
                        $this->eventDispatcher->listen('eloquent.booted: *', function ($model, $data = null) use ($scope) {
                                if (is_string($model) && is_array($data)) { // Laravel 5.4 wildcard event
                                        $model = reset($data);
                                }

                                $model->addGlobalScope($scope);
                        });
                }

                if (class_exists(\Illuminate\Database\Events\QueryExecuted::class)) {
                        // Laravel 5.2 and up
                        $this->eventDispatcher->listen(\Illuminate\Database\Events\QueryExecuted::class, function ($event) {
                                $this->registerQuery($event);
                        });
                } else {
                        // Laravel 5.0 to 5.1
                        $this->eventDispatcher->listen('illuminate.query', function ($event) {
                                $this->registerLegacyQuery($event);
                        });
                }

                // register all event listeners individually so we don't have to regex the event type and support Laravel <5.4
                $this->listenToModelEvent('retrieved');
                $this->listenToModelEvent('created');
                $this->listenToModelEvent('updated');
                $this->listenToModelEvent('deleted');
        }

        // Register a listener collecting model events of specified type
        protected function listenToModelEvent($event)
        {
                $this->eventDispatcher->listen("eloquent.{$event}: *", function ($model, $data = null) use ($event) {
                        if (is_string($model) && is_array($data)) { // Laravel 5.4 wildcard event
                                $model = reset($data);
                        }

                        $this->collectModelEvent($event, $model);
                });
        }

        // Collect an executed database query
        protected function registerQuery($event)
        {
                $trace = StackTrace::get([ 'arguments' => $this->detectDuplicateQueries ])->resolveViewName();

                if ($this->detectDuplicateQueries) $this->detectDuplicateQuery($trace);

                $query = [
                        'query'      => $this->createRunnableQuery($event->sql, $event->bindings, $event->connectionName),
                        'duration'   => $event->time,
                        'connection' => $event->connectionName,
                        'time'       => microtime(true) - $event->time / 1000,
                        'trace'      => (new Serializer)->trace($trace),
                        'model'      => $this->nextQueryModel,
                        'tags'       => $this->slowThreshold !== null && $event->time > $this->slowThreshold ? [ 'slow' ] : []
                ];

                $this->nextQueryModel = null;

                if (! $this->passesFilters([ $query, $trace ], 'early')) return;

                $this->incrementQueryCount($query);

                if (! $this->collectQueries || ! $this->passesFilters([ $query, $trace ])) return;

                $this->queries[] = $query;
        }

        // Collect an executed database query (pre Laravel 5.2)
        protected function registerLegacyQuery($sql, $bindings, $time, $connection)
        {
                return $this->registerQuery((object) [
                        'sql'            => $sql,
                        'bindings'       => $bindings,
                        'time'           => $time,
                        'connectionName' => $connection
                ]);
        }

        // Collect a model event and update stats
        protected function collectModelEvent($event, $model)
        {
                $lastQuery = ($queryCount = count($this->queries)) ? $this->queries[$queryCount - 1] : null;

                $action = [
                        'model'      => $modelClass = get_class($model),
                        'key'        => $this->getModelKey($model),
                        'action'     => $event,
                        'attributes' => $this->collectModelsRetrieved && $event == 'retrieved' ? $model->getOriginal() : [],
                        'changes'    => $this->collectModelsActions ? $model->getChanges() : [],
                        'time'       => microtime(true) / 1000,
                        'query'      => $lastQuery ? $lastQuery['query'] : null,
                        'duration'   => $lastQuery ? $lastQuery['duration'] : null,
                        'connection' => $lastQuery ? $lastQuery['connection'] : null,
                        'trace'      => null,
                        'tags'       => []
                ];

                if ($lastQuery) $this->queries[$queryCount - 1]['model'] = $modelClass;

                if (! $this->passesFilters([ $action ], 'models-early')) return;

                $this->incrementModelsCount($action['action'], $action['model']);

                if (! $this->collectModelsActions) return;
                if (! $this->collectModelsRetrieved && $event == 'retrieved') return;
                if (! $this->passesFilters([ $action ], 'models')) return;

                $action['trace'] = (new Serializer)->trace(StackTrace::get()->resolveViewName());

                $this->modelsActions[] = $action;
        }

        // Takes a query, an array of bindings and the connection as arguments, returns runnable query with upper-cased keywords
        protected function createRunnableQuery($query, $bindings, $connection)
        {
                // add bindings to query
                $bindings = $this->databaseManager->connection($connection)->prepareBindings($bindings);

                $index = 0;
                $query = preg_replace_callback('/\?/', function ($matches) use ($bindings, $connection, &$index) {
                        $binding = $this->quoteBinding($bindings[$index++], $connection);

                        // convert binary bindings to hexadecimal representation
                        if (! preg_match('//u', (string) $binding)) $binding = '0x' . bin2hex($binding);

                        // escape backslashes in the binding (preg_replace requires to do so)
                        return (string) $binding;
                }, $query, count($bindings));

                // highlight keywords
                $keywords = [
                        'select', 'insert', 'update', 'delete', 'into', 'values', 'set', 'where', 'from', 'limit', 'is', 'null',
                        'having', 'group by', 'order by', 'asc', 'desc'
                ];
                $regexp = '/\b' . implode('\b|\b', $keywords) . '\b/i';

                return preg_replace_callback($regexp, function ($match) { return strtoupper($match[0]); }, $query);
        }

        // Takes a query binding and a connection name, returns a quoted binding value
        protected function quoteBinding($binding, $connection)
        {
                $connection = $this->databaseManager->connection($connection);

                if (! method_exists($connection, 'getPdo')) return;

                $pdo = $connection->getPdo();

                if ($pdo === null) return;

                if ($pdo->getAttribute(\PDO::ATTR_DRIVER_NAME) === 'odbc') {
                        // PDO_ODBC driver doesn't support the quote method, apply simple MSSQL style quoting instead
                        return "'" . str_replace("'", "''", $binding) . "'";
                }

                return is_string($binding) ? $pdo->quote($binding) : $binding;
        }

        // Increment query counts for collected query
        protected function incrementQueryCount($query)
        {
                $sql = ltrim($query['query']);

                $this->count['total']++;

                if (preg_match('/^select\b/i', $sql)) {
                        $this->count['select']++;
                } elseif (preg_match('/^insert\b/i', $sql)) {
                        $this->count['insert']++;
                } elseif (preg_match('/^update\b/i', $sql)) {
                        $this->count['update']++;
                } elseif (preg_match('/^delete\b/i', $sql)) {
                        $this->count['delete']++;
                } else {
                        $this->count['other']++;
                }

                if (in_array('slow', $query['tags'])) {
                        $this->count['slow']++;
                }
        }

        // Increment model counts for collected model action
        protected function incrementModelsCount($action, $model)
        {
                if (! isset($this->modelsCount[$action][$model])) {
                        $this->modelsCount[$action][$model] = 0;
                }

                $this->modelsCount[$action][$model]++;
        }

        // Returns model resolving scope for the installed Laravel version
        protected function getModelResolvingScope()
        {
                if (interface_exists(\Illuminate\Database\Eloquent\ScopeInterface::class)) {
                        // Laravel 5.0 to 5.1
                        return new ResolveModelLegacyScope($this);
                }

                return new ResolveModelScope($this);
        }

        // Returns model key without crashing when using Eloquent strict mode and it's not loaded
        protected function getModelKey($model)
        {
                try {
                        return $model->getKey();
                } catch (\Illuminate\Database\Eloquent\MissingAttributeException $e) {}
        }
}