improve code style

Feature/sql status

.php-cs-fixer.php

@@ -0,0 +1,13 @@
+<?php
+
+$finder = PhpCsFixer\Finder::create()
+    ->in(__DIR__)
+;
+
+$config = new PhpCsFixer\Config();
+return $config->setRules([
+        '@PHP80Migration' => true,
+        '@PSR12' => true
+    ])
+    ->setFinder($finder)
+;

CHANGELOG.md

@@ -4,20 +4,53 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [Unreleased](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.3.3...master)
 
-## [1.1.0] - 2019-09-20
+## [1.3.3](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.3.2...1.3.3) - 2022-09-05
+### Fixed
+- fix argument error if no parameter list was set in stopDebug
+
+## [1.3.2](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.3.1...1.3.2) - 2022-07-18
+### Fixed
+- fix some code style issues
+
+## [1.3.1](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.3.0...1.3.1) - 2021-04-29
+### Fixed
+- prevent the use of not countable parameters in prepared statemant rendering 
+
+## [1.3.0](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.2.2...1.3.0) - 2021-03-02
+### Fixed
+- fix missing static methods
 
 ### Added
+- add configurable FirePHP handler
 
+## [1.2.2](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.2.1...1.2.2) - 2021-01-23
+### Changed
+- change static methods to non-static methods for better testable code
+- change line endings for easy patching
+
+### Added
+- add prepared statement generator
+
+## [1.2.1](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.2.0...1.2.1) - 2020-05-01
+### Fixed
+- add missing autoload file item in composer.json
+
+## [1.2.0](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.1.0...1.2.0) - 2020-04-30
+### Added
+- Format SQL query 
+- Measures the SQL execution time
+
+## [1.1.0](https://git.d3data.de/D3Public/oxid-sql-logger/compare/1.0.0...1.1.0) - 2019-09-20
+### Added
 - add log message
 - add position specifications of the calling source code 
 
-## [1.0.0] - 2019-07-21
+## [1.0.0](https://git.d3data.de/D3Public/oxid-sql-logger/releases/tag/1.0.0) - 2019-07-21
 
 available in tumtum/oxid-sql-logger package only
 
 ### Added
-
 - Global function `StartSQLLog` and `StopSQLLog`
-- Display SQL Querys on Browser or CLI
+- Display SQL Querys on Browser or CLI

README.md

@@ -24,9 +24,39 @@ $list = $db->getAll('SELECT * FROM oxarticles WHERE oxprice < ? LIMIT 100', [49.
 
 Browser:
 
-![Example all sqls](https://raw.githubusercontent.com/TumTum/oxid-sql-logger/master/img/screenshot-a.jpg)
+![Example all sqls](https://raw.githubusercontent.com/d3datadevelopment/oxid-sql-logger/master/img/screenshot-a.jpg)
 
 CLI:
 
-![Example CLI](https://raw.githubusercontent.com/TumTum/oxid-sql-logger/master/img/screenshot-cli.jpg)
+![Example CLI](https://raw.githubusercontent.com/d3datadevelopment/oxid-sql-logger/master/img/screenshot-cli.jpg)
 
+## Configuration
+
+Add the sections to the config.inc.php of the shop if needed:
+
+```php
+$this->SqlLoggerGUIHandlers = [
+    \Monolog\Handler\BrowserConsoleHandler::class,
+    \D3\OxidSqlLogger\Handler\d3FirePHPHandler::class
+];
+```
+
+Standard handlers are BrowserConsoleHandler and d3FirePHPHandler.
+
+```php
+$this->SqlLoggerCLIHandlers = [
+    ...
+];
+```
+
+Standard handler is StreamHandler.
+
+```php
+$this->d3FirePHPOptions = [
+    \D3\OxidSqlLogger\Handler\d3FirePHPHandler::ADD_TRACE
+];
+```
+
+## Credits
+
+Many thanks to [Tobias Matthaiou](https://github.com/TumTum/oxid-sql-logger) for his inspiration.

composer.json

@@ -3,7 +3,14 @@
     "description": "Returns all SQL queries in the browser.",
     "type": "library",
     "require": {
-        "monolog/monolog": "^1"
+        "php": "^8.0",
+        "monolog/monolog": "^1",
+        "nilportugues/sql-query-formatter": "^1.2.2",
+        "firephp/firephp-core": "^0.5.3"
+    },
+    "require-dev": {
+        "friendsofphp/php-cs-fixer": "~3.13.0",
+        "phpstan/phpstan": "^1.10"
     },
     "license": "GPL-3.0",
     "autoload": {
@@ -22,7 +29,12 @@
         {
             "name": "D3 Data Development (Inh. Thomas Dartsch)",
             "email": "info@shopmodule.com",
-            "homepage": "http://www.d3data.de"
+            "homepage": "https://www.d3data.de"
         }
-    ]
+    ],
+    "scripts": {
+        "php-cs-fixer": "./vendor/bin/php-cs-fixer fix --config=vendor/d3/oxid-sql-logger/.php-cs-fixer.php",
+
+        "phpstan": "./vendor/bin/phpstan --configuration=vendor/d3/oxid-sql-logger/phpstan.neon analyse"
+    }
 }

example/simple.php

@@ -1,19 +1,23 @@
 <?php
 
+declare(strict_types=1);
+
+use OxidEsales\Eshop\Core\DatabaseProvider;
+
 require __DIR__ . '/../../../../source/bootstrap.php';
 
-\D3StartSQLLog('Query for 100 items cheaper than 49,99');
+D3StartSQLLog('Query for 100 items cheaper than 49,99');
 
-$db = \OxidEsales\Eshop\Core\DatabaseProvider::getDb(\OxidEsales\Eshop\Core\DatabaseProvider::FETCH_MODE_ASSOC);
+$db = DatabaseProvider::getDb(DatabaseProvider::FETCH_MODE_ASSOC);
 $list = $db->getAll('SELECT * '.PHP_EOL.'FROM oxarticles WHERE oxprice < ? LIMIT 100', [49.99]);
 
-\D3StopSQLLog();
+D3StopSQLLog();
 
 // or
 
-\D3StartSQLLog();
+D3StartSQLLog();
 
-$db = \OxidEsales\Eshop\Core\DatabaseProvider::getDb(\OxidEsales\Eshop\Core\DatabaseProvider::FETCH_MODE_ASSOC);
+$db = DatabaseProvider::getDb(DatabaseProvider::FETCH_MODE_ASSOC);
 $list = $db->getAll('SELECT * FROM oxarticles WHERE oxprice < ? LIMIT 100', [49.99]);
 
-\D3StopSQLLog();
+D3StopSQLLog();

phpstan.neon

@@ -0,0 +1,14 @@
+parameters:
+    scanFiles:
+        - ../../oxid-esales/oxideshop-ce/source/bootstrap.php
+        - ../../oxid-esales/oxideshop-ce/source/oxfunctions.php
+        - ../../oxid-esales/oxideshop-ce/source/overridablefunctions.php
+    paths:
+        - ./src
+        - ./example
+    level: 9
+    phpVersion: 80300
+    checkMissingIterableValueType: false
+    treatPhpDocTypesAsCertain: false
+    featureToggles:
+        disableRuntimeReflectionProvider: true

src/Extensions/d3FirePHP.php

@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * https://www.d3data.de
+ *
+ * @copyright (C) D3 Data Development (Inh. Thomas Dartsch)
+ * @author    D3 Data Development - Daniel Seifert <support@shopmodule.com>
+ * @link      https://www.oxidmodule.com
+ */
+
+declare(strict_types=1);
+
+namespace D3\OxidSqlLogger\Extensions;
+
+use D3\OxidSqlLogger\Handler\d3FirePHPHandler;
+use D3\OxidSqlLogger\OxidSQLLogger;
+use Doctrine\DBAL\Connection;
+use Exception;
+use FirePHP;
+use Monolog\Handler\AbstractProcessingHandler;
+use Monolog\Logger;
+use OxidEsales\EshopCommunity\Core\Database\Adapter\Doctrine\Database;
+
+class d3FirePHP extends FirePHP
+{
+    /**
+     * Gets singleton instance of FirePHP
+     *
+     * @param boolean $autoCreate
+     * @return FirePHP
+     */
+    public static function getInstance($autoCreate = false): FirePHP
+    {
+        if ($autoCreate === true && !self::$instance) {
+            self::init();
+        }
+        return self::$instance;
+    }
+
+    /**
+     * Creates FirePHP object and stores it for singleton access
+     *
+     * @return FirePHP
+     */
+    public static function init(): FirePHP
+    {
+        return self::setInstance(new self());
+    }
+
+    public function __construct()
+    {
+        parent::__construct();
+
+        $this->ignoreClassInTraces(d3FirePHP::class);
+        $this->ignoreClassInTraces(d3FirePHPHandler::class);
+        $this->ignoreClassInTraces(Logger::class);
+        $this->ignoreClassInTraces(AbstractProcessingHandler::class);
+        $this->ignoreClassInTraces(OxidSQLLogger::class);
+        $this->ignoreClassInTraces(Connection::class);
+        $this->ignoreClassInTraces(Database::class);
+    }
+
+    /**
+     * Log a trace in the firebug console
+     *
+     * @see FirePHP::TRACE
+     * @param string $label
+     * @return bool
+     * @throws Exception
+     */
+    public function trace($label): bool
+    {
+        return $this->fb($label, $label, FirePHP::TRACE, [
+            'trace' => debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS),
+        ]);
+    }
+}

src/Handler/d3FirePHPHandler.php

@@ -0,0 +1,50 @@
+<?php
+
+/**
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * https://www.d3data.de
+ *
+ * @copyright (C) D3 Data Development (Inh. Thomas Dartsch)
+ * @author    D3 Data Development - Daniel Seifert <support@shopmodule.com>
+ * @link      https://www.oxidmodule.com
+ */
+
+declare(strict_types=1);
+
+namespace D3\OxidSqlLogger\Handler;
+
+use D3\OxidSqlLogger\Extensions\d3FirePHP;
+use Exception;
+use Monolog\Handler\AbstractProcessingHandler;
+use OxidEsales\Eshop\Core\Registry;
+
+class d3FirePHPHandler extends AbstractProcessingHandler
+{
+    public const ADD_TRACE = 'addTrace';
+
+    /**
+     * @param array $record
+     *
+     * @throws Exception
+     */
+    protected function write(array $record): void
+    {
+        $options = Registry::getConfig()->getConfigParam('d3FirePHPOptions');
+        $options = isset($options) && is_array($options) ? $options : [];
+
+        $fp = d3FirePHP::getInstance(true);
+
+        if (in_array(self::ADD_TRACE, $options)) {
+            $fp->group($record['message'], [ 'Collapsed' => true ]);
+        }
+
+        $fp->log($record['formatted'], $record['message']);
+
+        if (in_array(self::ADD_TRACE, $options)) {
+            $fp->trace('trace');
+            $fp->groupEnd();
+        }
+    }
+}

src/LoggerFactory.php

@@ -5,21 +5,23 @@
  * @author    D3 Data Development - Daniel Seifert <support@shopmodule.com>
  */
 
+declare(strict_types=1);
+
 namespace D3\OxidSqlLogger;
 
 use Monolog;
+use Monolog\Logger;
+use OxidEsales\Eshop\Core\Registry;
 use Symfony\Component\Console\Formatter\OutputFormatterStyle;
 
-/**
- * Class Factory
- */
 class LoggerFactory
 {
     /**
-     * @param $name
-     * @return Monolog\Logger
+     * @param string $name
+     *
+     * @return Logger
      */
-    public function create($name)
+    public function create(string $name): Monolog\Logger
     {
         return new Monolog\Logger($name, $this->getHandlers(), $this->getProcessors());
     }
@@ -27,22 +29,49 @@ class LoggerFactory
     /**
      * @return array
      */
-    private function getHandlers()
+    private function getHandlers(): array
     {
-        $handlers = [];
         if (PHP_SAPI == 'cli') {
-            $handlers[] = $this->getStreamHandler();
+            $configuredHandlers = Registry::getConfig()->getConfigParam('SqlLoggerCLIHandlers');
+
+            $handlers = (isset($configuredHandlers) && is_iterable($configuredHandlers)) ?
+                $this->getInstancesFromHandlerList($configuredHandlers) :
+                [
+                    $this->getStreamHandler(),
+                ];
         } else {
-            $handlers[] = $this->getBrowserConsoleHandler();
-            $handlers[] = $this->getFirePHPHandler();
+            $configuredHandlers = Registry::getConfig()->getConfigParam('SqlLoggerGUIHandlers');
+
+            $handlers = (isset($configuredHandlers) && is_iterable($configuredHandlers)) ?
+                $this->getInstancesFromHandlerList($configuredHandlers) :
+                [
+                    $this->getBrowserConsoleHandler(),
+                    $this->getFirePHPHandler(),
+                ];
         }
+
         return $handlers;
     }
 
+    /**
+     * @param iterable $classNames
+     *
+     * @return array
+     */
+    private function getInstancesFromHandlerList(iterable $classNames): array
+    {
+        return array_map(
+            function ($className) {
+                return new $className();
+            },
+            (array) $classNames
+        );
+    }
+
     /**
      * @return Monolog\Handler\StreamHandler
      */
-    private function getStreamHandler()
+    private function getStreamHandler(): Monolog\Handler\StreamHandler
     {
         $streamHandler = new Monolog\Handler\StreamHandler('php://stderr');
 
@@ -52,7 +81,7 @@ class LoggerFactory
         $context    = (new OutputFormatterStyle('yellow'))->apply('%context%');
         $newline    = PHP_EOL . str_repeat(' ', 10);
 
-        $ttl_color = "$channel $level_name: $message {$newline} $context {$newline} %extra%" . PHP_EOL;
+        $ttl_color = "$channel $level_name: $message $newline $context $newline %extra%" . PHP_EOL;
 
         $streamHandler->setFormatter(
             new Monolog\Formatter\LineFormatter(
@@ -69,7 +98,7 @@ class LoggerFactory
     /**
      * @return Monolog\Handler\BrowserConsoleHandler
      */
-    private function getBrowserConsoleHandler()
+    private function getBrowserConsoleHandler(): Monolog\Handler\BrowserConsoleHandler
     {
         return new Monolog\Handler\BrowserConsoleHandler();
     }
@@ -77,7 +106,7 @@ class LoggerFactory
     /**
      * @return Monolog\Handler\FirePHPHandler
      */
-    private function getFirePHPHandler()
+    private function getFirePHPHandler(): Monolog\Handler\FirePHPHandler
     {
         return new Monolog\Handler\FirePHPHandler();
     }
@@ -85,10 +114,17 @@ class LoggerFactory
     /**
      * @return array
      */
-    private function getProcessors()
+    private function getProcessors(): array
     {
         return [
-            new Monolog\Processor\IntrospectionProcessor(Monolog\Logger::DEBUG, ['D3\\OxidSqlLogger', 'Doctrine\\DBAL\\Connection', 'OxidEsales\\EshopCommunity\\Core\\Database\\Adapter\\Doctrine\\Database']),
+            new Monolog\Processor\IntrospectionProcessor(
+                Monolog\Logger::DEBUG,
+                [
+                    'D3\\OxidSqlLogger',
+                    'Doctrine\\DBAL\\Connection',
+                    'OxidEsales\\EshopCommunity\\Core\\Database\\Adapter\\Doctrine\\Database',
+                ]
+            ),
             new Monolog\Processor\PsrLogMessageProcessor(),
         ];
     }

src/OxidEsalesDatabase.php

@@ -5,48 +5,72 @@
  * @author    D3 Data Development - Daniel Seifert <support@shopmodule.com>
  */
 
+declare(strict_types=1);
+
 namespace D3\OxidSqlLogger;
 
 use Doctrine\DBAL\Configuration;
+use Doctrine\DBAL\Logging\SQLLogger;
+use OxidEsales\Eshop\Core\Database\Adapter\Doctrine\Database;
+use OxidEsales\EshopCommunity\Internal\Container\ContainerFactory;
+use OxidEsales\EshopCommunity\Internal\Framework\Database\ConnectionProvider;
+use OxidEsales\EshopCommunity\Internal\Framework\Database\ConnectionProviderInterface;
+use Psr\Container\ContainerExceptionInterface;
+use Psr\Container\NotFoundExceptionInterface;
 
-/**
- * Class OxidEsalesDatabase
- * Is a depenction injection Helper Class
- */
-class OxidEsalesDatabase extends \OxidEsales\Eshop\Core\Database\Adapter\Doctrine\Database
+class OxidEsalesDatabase extends Database
 {
-    public static function enableLogger($message = null)
+    /**
+     * @param string|null $message
+     *
+     * @return void
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
+     */
+    public function d3EnableLogger(string $message = null): void
     {
-        $trace = debug_backtrace((PHP_VERSION_ID < 50306) ? 2 : DEBUG_BACKTRACE_IGNORE_ARGS);
+        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
 
-        $database = \OxidEsales\Eshop\Core\DatabaseProvider::getDb(\OxidEsales\Eshop\Core\DatabaseProvider::FETCH_MODE_ASSOC);
-        $dbalConfig = $database->getConnection()->getConfiguration();
-        $dbalConfig->setSQLLogger(
+        $this->d3GetConfiguration()->setSQLLogger(
             new OxidSQLLogger(
-                isset($trace[1]['file']) ? $trace[1]['file'] : null,
-                isset($trace[1]['line']) ? $trace[1]['line'] : null,
-                isset($trace[2]['class']) ? $trace[2]['class'] : null,
-                isset($trace[2]['function']) ? $trace[2]['function'] : null,
+                $trace[1]['file'] ?? '',
+                array_key_exists('line', $trace[1]) ? (int) $trace[1]['line'] : 0,
+                $trace[2]['class'] ?? '',
+                $trace[2]['function'] ?? '',
                 $message
             )
         );
     }
 
     /**
-     * @return OxidSQLLogger
-     * @throws \OxidEsales\Eshop\Core\Exception\DatabaseConnectionException
+     * @return SQLLogger|null
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
      */
-    public static function getLogger()
+    public function d3GetLogger(): ?SQLLogger
     {
-        $database = \OxidEsales\Eshop\Core\DatabaseProvider::getDb(\OxidEsales\Eshop\Core\DatabaseProvider::FETCH_MODE_ASSOC);
-        $dbalConfig = $database->getConnection()->getConfiguration();
-        return $dbalConfig->getSQLLogger();
+        return $this->d3GetConfiguration()->getSQLLogger();
     }
 
-    public static function disableLogger()
+    /**
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
+     */
+    public function d3DisableLogger(): void
     {
-        $database = \OxidEsales\Eshop\Core\DatabaseProvider::getDb(\OxidEsales\Eshop\Core\DatabaseProvider::FETCH_MODE_ASSOC);
-        $dbalConfig = $database->getConnection()->getConfiguration();
-        $dbalConfig->setSQLLogger(null);
+        $this->d3GetConfiguration()->setSQLLogger();
+    }
+
+    /**
+     * @return Configuration
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
+     */
+    protected function d3GetConfiguration(): Configuration
+    {
+        /** @var ConnectionProvider $connectionProvider */
+        $connectionProvider = ContainerFactory::getInstance()->getContainer()
+                                              ->get(ConnectionProviderInterface::class);
+        return $connectionProvider->get()->getConfiguration();
     }
 }

src/OxidSQLLogger.php

@@ -5,32 +5,39 @@
  * @author    D3 Data Development - Daniel Seifert <support@shopmodule.com>
  */
 
+declare(strict_types=1);
+
 namespace D3\OxidSqlLogger;
 
+use D3\ModCfg\Application\Model\d3database;
 use Doctrine\DBAL\Logging\SQLLogger;
 use Monolog;
+use NilPortugues\Sql\QueryFormatter\Formatter;
 
-/**
- * Class OxidSQLLogger
- */
 class OxidSQLLogger implements SQLLogger
 {
-    public $message;
-    public $logStartingFile;
-    public $logStartingLine;
-    public $logStartingClass;
-    public $logStartingFunction;
+    public string $message;
+    public string $logStartingFile;
+    public int $logStartingLine;
+    public string $logStartingClass;
+    public string $logStartingFunction;
+
+    private SQLQuery|null $SQLQuery = null;
 
     /**
-     * @inheritDoc
+     * @param string      $file
+     * @param int         $line
+     * @param string      $class
+     * @param string      $function
+     * @param string|null $message
      */
-    public function __construct($file, $line, $class, $function, $message = null)
+    public function __construct(string $file, int $line, string $class, string $function, string $message = null)
     {
         if (!Monolog\Registry::hasLogger('sql')) {
             Monolog\Registry::addLogger((new LoggerFactory())->create('sql'));
         }
 
-        $this->message             = $message;
+        $this->message              = (string) $message;
         $this->logStartingFile      = $file;
         $this->logStartingLine      = $line;
         $this->logStartingClass     = $class;
@@ -38,29 +45,69 @@ class OxidSQLLogger implements SQLLogger
     }
 
     /**
-     * @inheritDoc
+     * @param string     $sql
+     * @param array|null $params
+     * @param array|null $types
      */
-    public function startQuery($sql, array $params = null, array $types = null)
+    public function startQuery($sql, ?array $params = null, ?array $types = null): void
     {
-        Monolog\Registry::sql()->addDebug(
-            $this->message ? $this->message : $sql,
-            [
-                'query'                 => $sql,
-                'params'                => $params,
-                'types'                 => $types,
-                'logStartingFile'       => $this->logStartingFile,
-                'logStartingLine'       => $this->logStartingLine,
-                'logStartingClass'      => $this->logStartingClass,
-                'logStartingFunction'   => $this->logStartingFunction,
+        if ($this->SQLQuery) {
+            $this->SQLQuery->setCanceled();
+            $this->stopQuery();
+        }
 
-            ]
-        );
+        $this->getPreparedStatementQuery($sql, $params ?? [], $types ?? []);
+
+        $this->SQLQuery = (new SQLQuery())->setSql($sql)
+            ->setParams($params)
+            ->setTypes($types)
+            ->setLogStartingFile($this->logStartingFile)
+            ->setLogStartingLine($this->logStartingLine)
+            ->setLogStartingClass($this->logStartingClass)
+            ->setLogStartingFunction($this->logStartingFunction);
+    }
+
+    /**
+     * @param string $sql
+     * @param array  $params
+     * @param array  $types
+     */
+    public function getPreparedStatementQuery(string &$sql, array $params = [], array $types = []): void
+    {
+        if (class_exists(d3database::class)
+            && method_exists(d3database::class, 'getPreparedStatementQuery')
+            && count($params)
+            && ($query = d3database::getInstance()->getPreparedStatementQuery($sql, $params, $types))
+            && strlen(trim($query))
+        ) {
+            $sql = $query;
+        }
     }
 
     /**
      * @inheritDoc
      */
-    public function stopQuery()
+    public function stopQuery(): void
     {
+        if ($this->SQLQuery) {
+            $formatter = new Formatter();
+
+            // @phpstan-ignore-next-line
+            Monolog\Registry::sql()->addDebug(
+                '['.$this->SQLQuery->getReadableElapsedTime().'] ' . ($this->message ?: $this->SQLQuery->getSql()),
+                [
+                    'query' => $formatter->format($this->SQLQuery->getSql()),
+                    'params' => $this->SQLQuery->getParams(),
+                    'time' => $this->SQLQuery->getElapsedTime(),
+                    'types' => $this->SQLQuery->getTypes(),
+                    'logStartingFile' => $this->SQLQuery->getLogStartingFile(),
+                    'logStartingLine' => $this->SQLQuery->getLogStartingLine(),
+                    'logStartingClass' => $this->SQLQuery->getLogStartingClass(),
+                    'logStartingFunction' => $this->SQLQuery->getLogStartingFunction(),
+                ]
+            );
+        }
+
+        $this->SQLQuery = null;
     }
 }

src/SQLQuery.php

@@ -0,0 +1,235 @@
+<?php
+
+/**
+ * @author    Tobias Matthaiou <developer@tobimat.eu>
+ * @author    D3 Data Development - Daniel Seifert <support@shopmodule.com>
+ */
+
+declare(strict_types=1);
+
+namespace D3\OxidSqlLogger;
+
+class SQLQuery
+{
+    /**
+     * @var float
+     */
+    private float $start_time;
+
+    /**
+     * @var float
+     */
+    private float $stop_time = 0.0;
+
+    /**
+     * @var string
+     */
+    private string $sql = '';
+
+    private ?array $parameters = null;
+
+    private ?array $parameterTypes = null;
+
+    private string $logStartingFile;
+
+    private int $logStartingLine;
+
+    private string $logStartingClass;
+
+    private string $logStartingFunction;
+
+    public function __construct()
+    {
+        $this->start_time = microtime(true);
+    }
+
+    /**
+     * @return string
+     */
+    public function getSql(): string
+    {
+        return $this->sql;
+    }
+
+    /**
+     * @param string $sql
+     * @return static
+     */
+    public function setSql(string $sql): static
+    {
+        $this->sql = $sql;
+        return $this;
+    }
+
+    /**
+     * @return array|null
+     */
+    public function getParams(): ?array
+    {
+        return $this->parameters;
+    }
+
+    /**
+     * @param array|null $params
+     *
+     * @return static
+     */
+    public function setParams(array $params = null): static
+    {
+        $this->parameters = $params;
+        return $this;
+    }
+
+    /**
+     * @return array|null
+     */
+    public function getTypes(): ?array
+    {
+        return $this->parameterTypes;
+    }
+
+    /**
+     * @param array|null $types
+     *
+     * @return static
+     */
+    public function setTypes(array $types = null): static
+    {
+        $this->parameterTypes = $types;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getLogStartingFile(): string
+    {
+        return $this->logStartingFile;
+    }
+
+    /**
+     * @param string $file
+     * @return static
+     */
+    public function setLogStartingFile(string $file): static
+    {
+        $this->logStartingFile = $file;
+        return $this;
+    }
+
+    public function getLogStartingLine(): int
+    {
+        return $this->logStartingLine;
+    }
+
+    /**
+     * @param int $line
+     *
+     * @return static
+     */
+    public function setLogStartingLine(int $line): static
+    {
+        $this->logStartingLine = $line;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getLogStartingClass(): string
+    {
+        return $this->logStartingClass;
+    }
+
+    /**
+     * @param string $classname
+     *
+     * @return static
+     */
+    public function setLogStartingClass(string $classname): static
+    {
+        $this->logStartingClass = $classname;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getLogStartingFunction(): string
+    {
+        return $this->logStartingFunction;
+    }
+
+    /**
+     * @param string $functionname
+     *
+     * @return static
+     */
+    public function setLogStartingFunction(string $functionname): static
+    {
+        $this->logStartingFunction = $functionname;
+        return $this;
+    }
+
+    /**
+     * Statement was cancelled prematurely, an error was thrown.
+     *
+     * @return static
+     */
+    public function setCanceled(): static
+    {
+        $this->start_time = 0.0;
+        return $this;
+    }
+
+    /**
+     * Return elapsed time
+     * @return float
+     */
+    public function getElapsedTime(): float
+    {
+        if ($this->start_time === 0.0) {
+            return 0.0;
+        }
+
+        if ($this->stop_time === 0.0) {
+            $end_time = microtime(true);
+            $this->stop_time = $end_time - $this->start_time;
+        }
+
+        return (float)$this->stop_time;
+    }
+
+    /**
+     * Returns a human-readable elapsed time
+     *
+     * @return string
+     */
+    public function getReadableElapsedTime(): string
+    {
+        return $this->readableElapsedTime($this->getElapsedTime());
+    }
+
+    /**
+     * Returns a human-readable elapsed time
+     *
+     * @param  float $microtime
+     * @param  string  $format   The format to display (printf format)
+     * @param int $round
+     * @return string
+     */
+    protected function readableElapsedTime(float $microtime, string $format = '%.3f%s', int $round = 3): string
+    {
+        if ($microtime >= 1) {
+            $unit = 's';
+            $time = round($microtime, $round);
+        } else {
+            $unit = 'ms';
+            $time = round($microtime*1000);
+
+            $format = (string) preg_replace('/(%.\d+f)/', '%d', $format);
+        }
+
+        return sprintf($format, $time, $unit);
+    }
+}

src/functions.php

@@ -5,10 +5,48 @@
  * @author    D3 Data Development - Daniel Seifert <support@shopmodule.com>
  */
 
-function D3StartSQLLog($message = null) {
-    \D3\OxidSqlLogger\OxidEsalesDatabase::enableLogger($message);
+declare(strict_types=1);
+
+use D3\OxidSqlLogger\OxidEsalesDatabase;
+use Psr\Container\ContainerExceptionInterface;
+use Psr\Container\NotFoundExceptionInterface;
+
+/**
+ * @param string|null $message
+ *
+ * @throws ContainerExceptionInterface
+ * @throws NotFoundExceptionInterface
+ */
+function D3StartSQLLog(string $message = null): void
+{
+    /** @var OxidEsalesDatabase $database */
+    $database = oxNew(OxidEsalesDatabase::class);
+    $database->d3EnableLogger($message);
 }
 
-function D3StopSQLLog() {
-    \D3\OxidSqlLogger\OxidEsalesDatabase::disableLogger();
+/**
+ * @throws ContainerExceptionInterface
+ * @throws NotFoundExceptionInterface
+ */
+function D3StopSQLLog(): void
+{
+    /** @var OxidEsalesDatabase $database */
+    $database = oxNew(OxidEsalesDatabase::class);
+    $database->d3DisableLogger();
+}
+
+/**
+ * @param string $message
+ *
+ * @throws ContainerExceptionInterface
+ * @throws NotFoundExceptionInterface
+ */
+function D3AddSQLLogItem(string $message): void
+{
+    /** @var OxidEsalesDatabase $database */
+    $database = oxNew(OxidEsalesDatabase::class);
+    if ($logger = $database->d3GetLogger()) {
+        $logger->startQuery($message);
+        $logger->stopQuery();
+    }
 }