/**
* @param DebugBar|null $debugBar
* @param Fdb|null $fdb
* @return $this
* @throws \DebugBar\DebugBarException
*/
public function addFdb(DebugBar $debugBar = null, Fdb $fdb = null)
{
if (null === $debugBar) {
return $this;
}
$fdb->createPool();
$collections = new PDOCollector();
foreach ($fdb as $name => $driverInterface) {
$traceablePDO = new TraceablePDO($driverInterface->getPdo());
$collections->addConnection($traceablePDO, $name);
}
$debugBar->addCollector($collections);
return $this;
}
/**
* If $name is null then the default connection will be returned.
*
* @see Config
* @param string $name Optional name of a connection
* @return Connection
*/
public static function get_connection($name = null)
{
$config = Config::instance();
$name = $name ? $name : $config->get_default_connection();
if (!isset(self::$connections[$name]) || !self::$connections[$name]->connection) {
self::$connections[$name] = Connection::instance($config->get_connection($name));
// If we have PHP DebugBar installed then we wrap the connection around it and register it
if (is_a(self::$connections[$name]->connection, 'PDO') && class_exists('DebugBar\\DebugBar') && self::$debugBarConnections != null) {
self::$connections[$name]->connection = new TraceablePDO(self::$connections[$name]->connection);
self::$debugBarConnections->addConnection(self::$connections[$name]->connection, $name . ' #' . (count(self::$debugBarConnections->getConnections()) + 1));
}
}
return self::$connections[$name];
}
public function __construct($eloquent_instance, TimeDataCollector $timeDataCollector = null)
{
parent::__construct();
self::$eloquent_instance = $eloquent_instance;
$this->timeDataCollector = $timeDataCollector;
$this->addConnection($this->getTraceablePdo(), 'Eloquent PDO');
}
/**
* Bootstrap any application services.
*
* @return void
* @throws \DebugBar\DebugBarException
* @throws \PeskyORM\Exception\DbConnectionConfigException
*/
public function boot()
{
$driver = config('database.default');
CmfDbModel::setDbConnectionConfig(DbConnectionConfig::create()->setDriver($driver)->setHost(config("database.connections.{$driver}.host"))->setDbName(config("database.connections.{$driver}.database"))->setUserName(config("database.connections.{$driver}.username"))->setPassword(config("database.connections.{$driver}.password")));
DbColumnConfig::registerType('password', DbColumnConfig::DB_TYPE_VARCHAR, PasswordField::class);
if (config('app.debug', false) && app()->offsetExists('debugbar') && debugbar()->isEnabled()) {
$timeCollector = debugbar()->hasCollector('time') ? debugbar()->getCollector('time') : null;
$pdoCollector = new PDOCollector(null, $timeCollector);
$pdoCollector->setRenderSqlWithParams(true);
debugbar()->addCollector($pdoCollector);
Db::setConnectionWrapper(function (Db $db, \PDO $pdo) {
$pdoTracer = new PeskyOrmPdoTracer($pdo);
if (debugbar()->hasCollector('pdo')) {
debugbar()->getCollector('pdo')->addConnection($pdoTracer, $db->getDbName());
}
return $pdoTracer;
});
}
}
public function initPdoDatabase($config, $name)
{
try {
$pdo = new PDO("mysql:host=" . $config['host'] . ";charset=" . ($config['charset'] ?? 'utf8') . (isset($config['db']) ? ";dbname=" . $config['db'] : ''), $config['user'], $config['pass']);
} catch (PDOException $e) {
throw new Exception('Cannon instantiate database connection: ' . $e->getMessage());
}
$pdo->uniqueName = $config['host'] . "-" . $config['db'];
if ($this->context->exists(DebugBar::class)) {
$debugBar = $this->context->find(DebugBar::class);
$tracablePdo = new TraceablePDO($pdo);
if ($debugBar->hasCollector('pdo')) {
$pdoCollector = $debugBar->getCollector('pdo');
} else {
$debugBar->addCollector($pdoCollector = new PDOCollector());
}
if (false && !isset($config['default'])) {
$pdoCollector->addConnection($tracablePdo, 'default');
} else {
$pdoCollector->addConnection($tracablePdo, $name);
}
}
return new RepositoryPDO($pdo, $name);
}
/**
* Boot the debugbar (add collectors, renderer and listener)
*/
public function boot()
{
if ($this->booted) {
return;
}
$debugbar = $this;
$app = $this->app;
if ($this->app['config']->get('laravel-debugbar::config.storage.enabled')) {
$path = $this->app['config']->get('laravel-debugbar::config.storage.path');
$storage = new FilesystemStorage($this->app['files'], $path);
$debugbar->setStorage($storage);
}
if ($this->shouldCollect('phpinfo', true)) {
$this->addCollector(new PhpInfoCollector());
}
if ($this->shouldCollect('messages', true)) {
$this->addCollector(new MessagesCollector());
}
if ($this->shouldCollect('time', true)) {
$this->addCollector(new TimeDataCollector());
$this->app->booted(function () use($debugbar) {
if (defined('LARAVEL_START')) {
$debugbar['time']->addMeasure('Booting', LARAVEL_START, microtime(true));
}
});
//Check if App::before is already called..
if (version_compare($app::VERSION, '4.1', '>=') && $this->app->isBooted()) {
$debugbar->startMeasure('application', 'Application');
} else {
$this->app->before(function () use($debugbar) {
$debugbar->startMeasure('application', 'Application');
});
}
$this->app->after(function () use($debugbar) {
$debugbar->stopMeasure('application');
$debugbar->startMeasure('after', 'After application');
});
}
if ($this->shouldCollect('memory', true)) {
$this->addCollector(new MemoryCollector());
}
if ($this->shouldCollect('exceptions', true)) {
$this->addCollector(new ExceptionsCollector());
}
if ($this->shouldCollect('laravel', false)) {
$this->addCollector(new LaravelCollector());
}
if ($this->shouldCollect('default_request', false)) {
$this->addCollector(new RequestDataCollector());
}
if ($this->shouldCollect('events', false) and isset($this->app['events'])) {
$this->addCollector(new MessagesCollector('events'));
$dispatcher = $this->app['events'];
$dispatcher->listen('*', function () use($debugbar, $dispatcher) {
if (method_exists($dispatcher, 'firing')) {
$event = $dispatcher->firing();
} else {
$args = func_get_args();
$event = end($args);
}
$debugbar['events']->info("Received event: " . $event);
});
}
if ($this->shouldCollect('views', true) and isset($this->app['events'])) {
$collectData = $this->app['config']->get('laravel-debugbar::config.options.views.data', true);
$this->addCollector(new ViewCollector($collectData));
$this->app['events']->listen('composing:*', function ($view) use($debugbar) {
$debugbar['views']->addView($view);
});
}
if ($this->shouldCollect('route')) {
if (version_compare($app::VERSION, '4.1', '>=')) {
$this->addCollector($this->app->make('Barryvdh\\Debugbar\\DataCollector\\IlluminateRouteCollector'));
} else {
$this->addCollector($this->app->make('Barryvdh\\Debugbar\\DataCollector\\SymfonyRouteCollector'));
}
}
if ($this->shouldCollect('log', true)) {
if ($this->hasCollector('messages')) {
$logger = new MessagesCollector('log');
$this['messages']->aggregate($logger);
$this->app['log']->listen(function ($level, $message, $context) use($logger) {
if (is_array($message) or is_object($message)) {
$message = json_encode($message);
}
$log = '[' . date('H:i:s') . '] ' . "LOG.{$level}: " . $message . (!empty($context) ? ' ' . json_encode($context) : '');
$logger->addMessage($log, $level);
});
} else {
$this->addCollector(new MonologCollector($this->app['log']->getMonolog()));
}
}
if ($this->shouldCollect('db', true) and isset($this->app['db'])) {
try {
$pdo = new TraceablePDO($this->app['db']->getPdo());
$pdoCollector = new PDOCollector($pdo);
if ($this->app['config']->get('laravel-debugbar::config.options.pdo.with_params')) {
$pdoCollector->setRenderSqlWithParams(true, $this->app['config']->get('laravel-debugbar::config.options.pdo.quotation_char'));
}
foreach ($this->app['config']->get('laravel-debugbar::config.options.pdo.extra_connections', array()) as $name) {
try {
$pdo = new TraceablePDO($this->app['db']->connection($name)->getPdo());
$pdoCollector->addConnection($pdo, $name);
} catch (\Exception $e) {
if ($this->hasCollector('exceptions')) {
$this['exceptions']->addException($e);
} elseif ($this->hasCollector('messages')) {
$this['messages']->error($e->getMessage());
}
}
}
$this->addCollector($pdoCollector);
} catch (\PDOException $e) {
//Not connection set..
}
}
if ($this->shouldCollect('twig') and isset($this->app['twig'])) {
$time = isset($this['time']) ? $this['time'] : null;
$this->app['twig'] = new TraceableTwigEnvironment($this->app['twig'], $time);
//If we already collect Views, skip the collector (but do add timing)
if (!$this->hasCollector('views')) {
$this->addCollector(new TwigCollector($this->app['twig']));
}
}
if ($this->shouldCollect('mail', true)) {
$mailer = $this->app['mailer']->getSwiftMailer();
$this->addCollector(new SwiftMailCollector($mailer));
if ($this->app['config']->get('laravel-debugbar::config.options.mail.full_log') and $this->hasCollector('messages')) {
$this['messages']->aggregate(new SwiftLogCollector($mailer));
}
}
if ($this->shouldCollect('config', false)) {
$this->addCollector(new ConfigCollector());
}
if ($this->shouldCollect('logs', false)) {
$file = $this->app['config']->get('laravel-debugbar::config.options.logs.file');
$this->addCollector(new LogsCollector($file));
}
if ($this->shouldCollect('files', false)) {
$this->addCollector(new FilesCollector());
}
if ($this->shouldCollect('auth', false)) {
$this->addCollector(new IlluminateAuthCollector($this->app['auth']));
}
$renderer = $this->getJavascriptRenderer();
$renderer->setBaseUrl(asset('packages/barryvdh/laravel-debugbar'));
$renderer->setIncludeVendors($this->app['config']->get('laravel-debugbar::config.include_vendors', true));
$this->booted = true;
}
public function __construct(\Illuminate\Database\Connection $db)
{
parent::__construct();
$this->db = $db;
$this->addConnection($this->getTraceablePdo(), 'Eloquent PDO');
}
public function __construct()
{
parent::__construct();
$this->addConnection($this->getTraceablePdo(), 'Betasyntax PDO');
}
