V.1.0.0 🔖 - Added more config options. Added max_rows logic. More unit tests. Set Travis to php7.2 and added code coverage testing.

Author: danielme85

.gitignore

@@ -11,6 +11,7 @@ Homestead.yaml
 .env
 .vagrant
 composer.lock
+coverage.xml
 .phpstorm.meta.php
 _ide_helper.php
 _ide_helper_models.php.php

.travis.yml

@@ -1,12 +1,15 @@
 language: php
 php:
-  - 7.1
+  - 7.2
 services:
   - mysql
   - mongodb
 before_script:
   - pecl install mongodb
   - mysql -e 'CREATE DATABASE testing;'
+  - composer self-update
   - composer install --no-interaction
 script:
-  - vendor/bin/phpunit
+  - vendor/bin/phpunit --coverage-clover=coverage.xml
+after_success:
+  - bash <(curl -s https://codecov.io/bash)

phpunit.xml

@@ -12,4 +12,12 @@
             <directory suffix=".php">./tests/</directory>
         </testsuite>
     </testsuites>
+    <filter>
+        <whitelist processUncoveredFilesFromWhitelist="true">
+            <directory suffix=".php">./src</directory>
+            <exclude>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
 </phpunit>

readme.md

@@ -1,26 +1,57 @@
 # Laravel Log-to-DB
-Custom Larvel 5.6+ Log channel handler that can store log events to SQL or MongoDB databases. 
-Uses Laravel native logging functionality.
-
 [![Travis (.org)](https://img.shields.io/travis/danielme85/laravel-log-to-db.svg?style=flat-square)](https://travis-ci.org/danielme85/laravel-log-to-db)
 [![GitHub](https://img.shields.io/github/license/mashape/apistatus.svg?style=flat-square)](https://github.com/danielme85/laravel-log-to-db)
 
+Custom Larvel 5.6+ Log channel handler that can store log events to SQL or MongoDB databases. 
+Uses Laravel native logging functionality.
+
 ### Installation
-```php
+```
 require danielme85/laravel-log-to-db
 ```
 
+If you are going to be using SQL database server to store log events you would need to run the migrations first. The MongoDB driver does not require the migration.
+```
+php artisan migrate
+```
+
 ### Configuration
 Starting with Laravel 5.6 you will have a new settings file: "config/logging.php". 
 You will need to add an array under 'channels' for Log-to-DB here like so:
 ```php
-    'database' => [
-        'driver' => 'custom',
-        'via' => danielme85\LaravelLogToDB\LogToDbHandler::class,
-        'level' => env('APP_LOG_LEVEL', 'debug'),
-    ]
+'database' => [
+    'driver' => 'custom',
+    'via' => danielme85\LaravelLogToDB\LogToDbHandler::class,
+    'level' => env('APP_LOG_LEVEL', 'debug'),
+    'name' => 'My DB Log',
+    'connection' => 'default',
+    'collection' => 'log',
+    'detailed' => true,
+    'max_rows' => false
+]
+```
+ * driver = Required to trigger the log driver.
+ * via = The Log handler class.
+ * level = The minimum error level to trigger this Log Channel.
+ * name = The channel name that will be stored with the Log event.
+ * connection = The DB connection from config/database.php to use (default: 'default').
+ * collection = The DB table or collection name. (Default: log).
+ * detailed = Store detailed log on Exceptions like stack-trace (default: true).
+ * max_rows = The number of rows/objects to allow before automatically removing the oldest (default: false).
+ 
+More info about some of these options: https://laravel.com/docs/5.6/logging#customizing-monolog-for-channels
+
+There are some default settings and more information about configuring the logger in the 'logtodb.php' config file.
+This can be copied to your project so you can edit it with the vendor publish command.
+```
+php artisan vendor:publish
+```
+You can give the logging channels whatever name you want instead of: 'database', as well as the log levels.
+The naming can be used later if you want to send a Log event to a specific channel:
+```php
+Log::channel('database')->info("This thing just happened");
+Log::channel('mongodb')->info("This thing just happened");
 ```
-You can give it whatever name you want as the array index instead of: 'database', as well as the log levels.
 This logger works the same as any other across Laravel, for example you can add it to a stack. 
 You can log multiple levels to multiple DB connections... the possibilities are ENDLESS! 😎
 ```php
@@ -61,27 +92,27 @@ You can log multiple levels to multiple DB connections... the possibilities are
 Since this is a custom log channel for Laravel, all "standard" ways of generating log events etc should work with 
 the Laravel Log Facade. See https://laravel.com/docs/5.6/logging for more information.
 
-#### Viewing/Getting The Log
-The logging by this channel is done trough the Eloquent Model builder. To get access to the underlying models use:
+#### Fetching Logs
+The logging by this channel is done trough the Eloquent Model builder.
+LogToDB::model($channel, $connection, $collection);
+You can skip all function variables and the default settings from the config/logtodb.php will be used.
 ```php
-$log = danielme85\LaravelLogToDB\LogToDB::model();
+$model = LogToDB::model();
+$model->all(); //All logs for defualt channel/connection
 ```
 
-Some examples of getting logs
+Some more examples of getting logs
 ```php
-//LogToDB::model() = The Eloquent model;
-
 $logs = LogToDB::model()->all();
 $logs = LogToDB::model()->where('id' = $id)->first();
-
-//or
-
-$log = danielme85\LaravelLogToDB\LogToDB::model();
-$log->all();
 ```
 
-Getting log for specific DB connection when using multiple DB storage methods.
+When getting logs for specific channel or DB connection and collection you can either use the channel name matching 
+config/logging.php or connection name from config/databases.php. You can also specify collection/table name if needed as 
+the third function variable when fetching the model.  
 ```php
-$logsFromDatabase = LogToDB::model('mysql')->all();
-$logsFromMongoDB = LogToDB::model('mongodb')->all();
+$logsFromDefault = LogDB::model()->all();
+$logsFromChannel = LogDB::model('database')->all();
+$logsFromMysql   = LogToDB::model(null, 'mysql')->all();
+$logsFromMongoDB = LogToDB::model(null, 'mongodb', 'log')->all();
 ```

src/LogToDB.php

@@ -9,41 +9,79 @@
  */
 class LogToDB
 {
+    /**
+     * Connection referenced in logging config.
+     * @var null
+     */
     public $channelConnection;
-
-    public $detailed = false;
-
-    public $maxRows = false;
-
-    //DB Connection to use
-    public $connection = 'default';
-
+    /**
+     * Store detailed log
+     * @var string
+     */
+    public $detailed;
+    /**
+     * Max number of allowed rows
+     * @var bool
+     */
+    public $maxRows;
+    /**
+     * Connection reference in databases config.
+     * @var string
+     */
+    public $connection;
+    /**
+     * The table in SQL or Collection in noSQL.
+     * @var string
+     */
     public $collection;
-
-    private $database = null;
+    /**
+     * The DB config details
+     * @var null
+     */
+    private $database;
 
     /**
      * LogToDB constructor.
+     *
+     * @param null $channelConnection
+     * @param null $collection
+     * @param null $detailed
+     * @param null $maxRows
      */
-    function __construct($channelConnection = null, $collection = 'log')
+    function __construct($channelConnection = null, $collection = null, $detailed = null, $maxRows = null)
     {
-        $this->channelConnection = $channelConnection;
-        $this->collection = $collection;
-
-        //Set config data
+        //Log default config if present
         $config = config('logtodb');
         if (!empty($config)) {
             if (isset($config['connection'])) {
                 $this->connection = $config['connection'];
             }
+            if (isset($config['collection'])) {
+                $this->collection = $config['collection'];
+            }
             if (isset($config['detailed'])) {
                 $this->detailed = $config['detailed'];
             }
             if (isset($config['max_rows'])) {
-                $this->maxRows = $config['max_rows'];
+                $this->maxRows = (int)$config['max_rows'];
             }
         }
 
+        //Set config based on specified config from the Log handler
+        if (!empty($channelConnection)) {
+            $this->channelConnection = $channelConnection;
+        }
+        if (!empty($collection)) {
+            $this->collection = $collection;
+        }
+        if (!empty($detailed)) {
+            $this->detailed = $detailed;
+        }
+        if (!empty($maxRows)) {
+            $this->maxRows = (int)$maxRows;
+        }
+
+        //Get the DB connections
         $dbconfig = config('database.connections');
 
         if (!empty($this->channelConnection)) {
@@ -67,10 +105,42 @@ function __construct($channelConnection = null, $collection = 'log')
     }
 
     /**
-     * @return string
+     * Return a new LogToDB Module instance.
+     *
+     * @param string|null $channel
+     * @param string|null $connection
+     * @param string|null $collection
+     *
+     * @return DBLog|DBLogMongoDB
      */
-    public static function model($channelConnection = null) {
-        $model = new self($channelConnection);
+    public static function model(string $channel = null, string $connection = null, string $collection = null)
+    {
+        $conn = null;
+        $coll = null;
+
+        if (!empty($channel)) {
+            $channels = config('logging.channels');
+            if (isset($channels[$channel])) {
+                if (isset($channels[$channel]['connection']) and !empty($channels[$channel]['connection'])) {
+                    $conn = $channels[$channel]['connection'];
+                }
+                if (isset($channels[$channel]['collection']) and !empty($channels[$channel]['collection'])) {
+                    $coll = $channels[$channel]['collection'];
+                }
+            }
+        }
+        else {
+            if (!empty($connection)) {
+                $conn = $connection;
+            }
+            if (!empty($collection)) {
+                $coll = $collection;
+            }
+        }
+
+        //Return new instance of this model
+        $model = new self($conn, $coll);
+
         return $model->getModel();
     }
 
@@ -96,7 +166,6 @@ private function getModel() {
      */
     public function newFromMonolog(array $record) : self
     {
-
         if ($this->database['driver'] === 'mongodb') {
             //MongoDB has its own Model
             $log = new DBLogMongoDB($this->connection, $this->collection);
@@ -109,10 +178,6 @@ public function newFromMonolog(array $record) : self
         if (isset($record['message'])) {
             $log->message = $record['message'];
         }
-        /**
-         * Storing the error log details takes quite a bit of space in sql database compared to a log file,
-         * so this can be disabled in the config.
-         */
         if ($this->detailed) {
             if (isset($record['context'])) {
                 if (!empty($record['context'])) {
@@ -139,9 +204,31 @@ public function newFromMonolog(array $record) : self
         }
         $log->unix_time = time();
 
-        $log->save();
+        if ($log->save()) {
+            if (!empty($this->maxRows)) {
+                $this->removeOldestIfMaxRows();
+            }
+        }
 
         return $this;
     }
 
+    /**
+     * Delete the oldest record based on unix_time
+     *
+     * @return bool success
+     */
+    private function removeOldestIfMaxRows() {
+        $model = $this->model();
+        $current = $model->count();
+        if ($current > $this->maxRows) {
+            $oldest = $model->orderBy('unix_time', 'ASC')->first();
+            if ($oldest->delete()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
 }

src/LogToDbCustomLoggingHandler.php

@@ -14,17 +14,25 @@ class LogToDbCustomLoggingHandler extends AbstractProcessingHandler
 {
     private $connection;
     private $collection;
+    private $detailed;
+    private $maxRows;
 
     /**
      * LogToDbHandler constructor.
      *
+     * @param string $connection The DB connection.
+     * @param string $collection The Collection/Table name for DB.
+     * @param bool $detailed Detailed error logging.
+     * @param int $maxRows The Maximum number of rows/objects before auto purge.
      * @param int $level The minimum logging level at which this handler will be triggered
      * @param bool $bubble Whether the messages that are handled can bubble up the stack or not
      */
-    function __construct($connection = 'default', $level = Logger::DEBUG, $collection = 'log', bool $bubble = true)
+    function __construct($connection, $collection, $detailed, $maxRows, $level = Logger::DEBUG, bool $bubble = true)
     {
         $this->connection = $connection;
         $this->collection = $collection;
+        $this->detailed = $detailed;
+        $this->maxRows = $maxRows;
 
         parent::__construct($level, $bubble);
     }
@@ -38,7 +46,7 @@ protected function write(array $record): void
     {
         if (!empty($record)) {
             try {
-                $log = new LogToDB($this->connection, $this->collection);
+                $log = new LogToDB($this->connection, $this->collection, $this->detailed, $this->maxRows);
                 $log->newFromMonolog($record);
             } catch (\Exception $e) {
                 //