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) {}

	}

}