├── modman
├── app
    ├── code
    │   └── community
    │   │   └── Aleron75
    │   │       └── Magemonolog
    │   │           ├── Model
    │   │               ├── HandlerWrapper
    │   │               │   ├── HandlerInterface.php
    │   │               │   ├── NewRelicHandler.php
    │   │               │   ├── NativeMailHandler.php
    │   │               │   ├── StreamHandler.php
    │   │               │   └── AbstractHandler.php
    │   │               └── Logwriter.php
    │   │           ├── Helper
    │   │               └── Data.php
    │   │           └── etc
    │   │               └── config.xml
    └── etc
    │   └── modules
    │       └── Aleron75_Magemonolog.xml
├── composer.json
└── README.md


/modman:
--------------------------------------------------------------------------------
1 | # Aleron75_Magemonolog definition
2 | app/etc/modules/*.xml                   app/etc/modules/
3 | app/code/community/Aleron75/*           app/code/community/Aleron75/
4 | 


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/Model/HandlerWrapper/HandlerInterface.php:
--------------------------------------------------------------------------------
1 | <?php
2 | interface Aleron75_Magemonolog_Model_HandlerWrapper_HandlerInterface
3 | {
4 |     function getHandler();
5 | }


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/Helper/Data.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by PhpStorm.
 4 |  * User: alessandro
 5 |  * Date: 10/6/14
 6 |  * Time: 6:25 AM
 7 |  */ 
 8 | class Aleron75_Magemonolog_Helper_Data extends Mage_Core_Helper_Abstract {
 9 | 
10 | }


--------------------------------------------------------------------------------
/app/etc/modules/Aleron75_Magemonolog.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0"?>
2 | <config>
3 |     <modules>
4 |         <Aleron75_Magemonolog>
5 |             <active>true</active>
6 |             <codePool>community</codePool>
7 |         </Aleron75_Magemonolog>
8 |     </modules>
9 | </config>


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "aleron75/magemonolog",
 3 |     "description": "A Magento extension to transparently use Monolog as logging library.",
 4 |     "type": "magento-module",
 5 |     "license": "OSL-3.0",
 6 |     "authors": [
 7 |         {
 8 |             "name": "Alessandro Ronchi",
 9 |             "email": "aleron75@gmail.com"
10 |         }
11 |     ],
12 |     "require": {
13 |         "magento-hackathon/magento-composer-installer": "*",
14 |         "firegento/psr0autoloader": "*",
15 |         "monolog/monolog": "*"
16 |     },
17 |     "repositories": [
18 |         {
19 |             "type": "composer",
20 |             "url": "http://packages.firegento.com"
21 |         }
22 |     ]
23 | }
24 | 


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/Model/HandlerWrapper/NewRelicHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use Monolog\Logger;
 3 | use \Monolog\Handler\NewRelicHandler;
 4 | 
 5 | class Aleron75_Magemonolog_Model_HandlerWrapper_NewRelicHandler
 6 |     extends Aleron75_Magemonolog_Model_HandlerWrapper_AbstractHandler
 7 | {
 8 |     public function __construct(array $args)
 9 |     {
10 |         $this->_validateArgs($args);
11 |         $this->_handler = new NewRelicHandler(
12 |             $args['level'],
13 |             $args['bubble'],
14 |             $args['appname']
15 |         );
16 |     }
17 | 
18 |     protected function _validateArgs(array &$args)
19 |     {
20 |         parent::_validateArgs($args);
21 | 
22 |         // Appname
23 |         $appname = '';
24 |         if (isset($args['appname']))
25 |         {
26 |             $appname = trim($args['appname']);
27 |         }
28 |         $args['appname'] = $appname;
29 |     }
30 | }


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/Model/HandlerWrapper/NativeMailHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use Monolog\Logger;
 3 | use \Monolog\Handler\NativeMailerHandler;
 4 | 
 5 | class Aleron75_Magemonolog_Model_HandlerWrapper_NativeMailHandler
 6 |     extends Aleron75_Magemonolog_Model_HandlerWrapper_AbstractHandler
 7 | {
 8 |     public function __construct(array $args)
 9 |     {
10 |         $this->_validateArgs($args);
11 |         $this->_handler = new NativeMailerHandler(
12 |             $args['to'],
13 |             $args['subject'],
14 |             $args['from'],
15 |             $args['level'],
16 |             $args['bubble'],
17 |             $args['maxColumnWidth']
18 |         );
19 |     }
20 | 
21 |     protected function _validateArgs(array &$args)
22 |     {
23 |         parent::_validateArgs($args);
24 | 
25 |         // To
26 |         $args['to'] = array_map('trim', explode(',', $args['to']));
27 | 
28 |         // Subject
29 |         $args['subject'] = trim($args['subject']);
30 | 
31 |         // From
32 |         $args['from'] = trim($args['from']);
33 | 
34 |         // Max Column Width
35 |         $maxColumnWidth = null;
36 |         if (isset($args['maxColumnWidth']) && is_numeric($args['maxColumnWidth']))
37 |         {
38 |             $maxColumnWidth = filter_var($args['maxColumnWidth'], FILTER_VALIDATE_INT);
39 |         }
40 |         $args['maxColumnWidth'] = $maxColumnWidth;
41 |     }
42 | }


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/Model/HandlerWrapper/StreamHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use Monolog\Logger;
 3 | use Monolog\Handler\StreamHandler;
 4 | 
 5 | class Aleron75_Magemonolog_Model_HandlerWrapper_StreamHandler
 6 |     extends Aleron75_Magemonolog_Model_HandlerWrapper_AbstractHandler
 7 | {
 8 |     public function __construct(array $args)
 9 |     {
10 |         $this->_validateArgs($args);
11 |         $this->_handler = new StreamHandler(
12 |             $args['stream'],
13 |             $args['level'],
14 |             $args['bubble'],
15 |             $args['filePermission'],
16 |             $args['useLocking']
17 |         );
18 |     }
19 | 
20 |     protected function _validateArgs(array &$args)
21 |     {
22 |         parent::_validateArgs($args);
23 | 
24 |         // Stream
25 |         $file = Mage::getStoreConfig('dev/log/file');
26 |         if (isset($args['stream']))
27 |         {
28 |             $file = $args['stream'];
29 |         }
30 |         $logDir  = Mage::getBaseDir('var') . DS . 'log';
31 |         $logFile = $logDir . DS . $file;
32 |         $args['stream'] = $logFile;
33 | 
34 |         // File Permission
35 |         $filePermission = null;
36 |         if (isset($args['filePermission']) && is_numeric($args['filePermission']))
37 |         {
38 |             $filePermission = filter_var($args['filePermission'], FILTER_VALIDATE_INT);
39 |         }
40 |         $args['filePermission'] = $filePermission;
41 | 
42 |         // Use Locking
43 |         $useLocking = false;
44 |         if (isset($args['useLocking']))
45 |         {
46 |             $useLocking = filter_var($args['useLocking'], FILTER_VALIDATE_BOOLEAN);
47 |         }
48 |         $args['useLocking'] = $useLocking;
49 |     }
50 | }


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/Model/HandlerWrapper/AbstractHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use Monolog\Logger;
 3 | 
 4 | abstract class Aleron75_Magemonolog_Model_HandlerWrapper_AbstractHandler
 5 |     implements Aleron75_Magemonolog_Model_HandlerWrapper_HandlerInterface
 6 | {
 7 |     protected $_handler = null;
 8 | 
 9 |     protected function _validateArgs(array &$args)
10 |     {
11 |         if (!is_array($args))
12 |         {
13 |             $args = array();
14 |         }
15 | 
16 |         // Level
17 |         $level = Logger::DEBUG;
18 |         if (isset($args['level']))
19 |         {
20 |             if (is_numeric($args['level']))
21 |             {
22 |                 $level = filter_var($args['level'], FILTER_VALIDATE_INT);
23 |             }
24 |             else
25 |             {
26 |                 $level = constant('Monolog\Logger::'. $args['level']);
27 |             }
28 | 
29 |             if (is_null($level))
30 |             {
31 |                 $level = Logger::DEBUG;
32 |             }
33 |         }
34 |         $args['level'] = $level;
35 | 
36 |         // Bubble
37 |         $bubble = true;
38 |         if (isset($args['bubble']))
39 |         {
40 |             $bubble = filter_var($args['bubble'], FILTER_VALIDATE_BOOLEAN);
41 |         }
42 |         $args['bubble'] = $bubble;
43 |     }
44 | 
45 |     public function getHandler()
46 |     {
47 |         return $this->_handler;
48 |     }
49 | 
50 |     /**
51 |      * @param \Monolog\Formatter\FormatterInterface $formatter
52 |      */
53 |     public function setFormatter(\Monolog\Formatter\FormatterInterface $formatter)
54 |     {
55 |         if ($this->_handler) {
56 |             $this->_handler->setFormatter($formatter);
57 |         }
58 |     }
59 | 
60 | }


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/etc/config.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <config>
 3 |     <modules>
 4 |         <Aleron75_Magemonolog>
 5 |             <version>0.3.0</version>
 6 |         </Aleron75_Magemonolog>
 7 |     </modules>
 8 |     <global>
 9 |         <models>
10 |             <aleron75_magemonolog>
11 |                 <class>Aleron75_Magemonolog_Model</class>
12 |             </aleron75_magemonolog>
13 |         </models>
14 |         <helpers>
15 |             <aleron75_magemonolog>
16 |                 <class>Aleron75_Magemonolog_Helper</class>
17 |             </aleron75_magemonolog>
18 |         </helpers>
19 |         <log>
20 |             <core>
21 |                 <writer_model>Aleron75_Magemonolog_Model_Logwriter</writer_model>
22 |             </core>
23 |         </log>
24 |     </global>
25 |     <default>
26 |         <magemonolog>
27 |             <handlers>
28 |                 <StreamHandler>
29 |                     <active>1</active>
30 |                     <params>
31 |                         <stream>magemonolog.log</stream>
32 |                         <level>DEBUG</level>
33 |                         <bubble>true</bubble>
34 |                         <filePermission>null</filePermission>
35 |                         <useLocking>false</useLocking>
36 |                     </params>
37 |                     <formatter>
38 |                         <class>LogstashFormatter</class>
39 |                         <args>
40 |                             <application_name><![CDATA[MyAppName]]></application_name>
41 |                             <system_name><![CDATA[]]></system_name>
42 |                             <extra_prefix><![CDATA[]]></extra_prefix>
43 |                             <context_prefix><![CDATA[]]></context_prefix>
44 |                             <version><![CDATA[]]></version>
45 |                         </args>
46 |                     </formatter>
47 |                 </StreamHandler>
48 |                 <NativeMailHandler>
49 |                     <active>0</active>
50 |                     <params>
51 |                         <to>dummy@example.com</to>
52 |                         <subject>Log</subject>
53 |                         <from>dummy@example.com</from>
54 |                         <level>ERROR</level>
55 |                         <bubble>true</bubble>
56 |                         <maxColumnWidth>70</maxColumnWidth>
57 |                     </params>
58 |                 </NativeMailHandler>
59 |                 <NewRelicHandler>
60 |                     <active>0</active>
61 |                     <params>
62 |                         <level>ERROR</level>
63 |                         <bubble>true</bubble>
64 |                         <appname>***your app name here***</appname>
65 |                     </params>
66 |                 </NewRelicHandler>
67 |             </handlers>
68 |         </magemonolog>
69 |     </default>
70 | </config>


--------------------------------------------------------------------------------
/app/code/community/Aleron75/Magemonolog/Model/Logwriter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | use Monolog\Logger;
  3 | 
  4 | class Aleron75_Magemonolog_Model_Logwriter
  5 |     extends Zend_Log_Writer_Abstract
  6 | {
  7 |     /**
  8 |      * @var string
  9 |      */
 10 |     protected $_logFile = null;
 11 | 
 12 |     /**
 13 |      * @var Monolog\Logger
 14 |      */
 15 |     protected $_logger = null;
 16 | 
 17 |     /**
 18 |      * Array used to map Zend's log levels into Monolog's
 19 |      *
 20 |      * @var array
 21 |      */
 22 |     protected $_levelMap = array();
 23 | 
 24 |     public function __construct($logFile)
 25 |     {
 26 |         $this->_logFile = $logFile;
 27 | 
 28 |         // Force autoloading
 29 |         Mage::dispatchEvent('add_spl_autoloader');
 30 | 
 31 |         // Initialize level mapping only after the Logger class is loaded
 32 |         $this->__initLevelMapping();
 33 | 
 34 |         $this->_logger = new Logger('monolog');
 35 | 
 36 |         $handlers = Mage::getStoreConfig('magemonolog/handlers');
 37 | 
 38 |         if (!is_null($handlers) && is_array($handlers))
 39 |         {
 40 |             foreach ($handlers as $handlerModel => $handlerValues)
 41 |             {
 42 |                 $isActive = Mage::getStoreConfigFlag('magemonolog/handlers/'.$handlerModel.'/active');
 43 |                 if (!$isActive)
 44 |                 {
 45 |                     continue;
 46 |                 }
 47 | 
 48 |                 $args = array();
 49 |                 if (array_key_exists('params', $handlerValues))
 50 |                 {
 51 |                     $args = $handlerValues['params'];
 52 |                     if (!empty($this->_logFile)){
 53 |                         $logFileParts = explode(DS,$this->_logFile);
 54 |                         $args['stream'] = array_pop($logFileParts);
 55 |                     }
 56 |                 }
 57 | 
 58 |                 $handlerWrapper = Mage::getModel('aleron75_magemonolog/handlerWrapper_'.$handlerModel, $args);
 59 | 
 60 |                 if (array_key_exists('formatter', $handlerValues)
 61 |                     && array_key_exists('class', $handlerValues['formatter']))
 62 |                 {
 63 |                     $class = new ReflectionClass('\\Monolog\Formatter\\'.$handlerValues['formatter']['class']);
 64 |                     $formatter = $class->newInstanceArgs($handlerValues['formatter']['args']);
 65 |                     $handlerWrapper->setFormatter($formatter);
 66 |                 }
 67 | 
 68 |                 $this->_logger->pushHandler($handlerWrapper->getHandler());
 69 |             }
 70 |         }
 71 |     }
 72 | 
 73 |     /**
 74 |      * Initialize the array used to map Zend's log levels into Monolog's
 75 |      */
 76 |     private function __initLevelMapping()
 77 |     {
 78 |         $this->_levelMap = array(
 79 |             Zend_Log::EMERG     => Logger::EMERGENCY,
 80 |             Zend_Log::ALERT     => Logger::ALERT,
 81 |             Zend_Log::CRIT      => Logger::CRITICAL,
 82 |             Zend_Log::ERR       => Logger::ERROR,
 83 |             Zend_Log::WARN      => Logger::WARNING,
 84 |             Zend_Log::NOTICE    => Logger::NOTICE,
 85 |             Zend_Log::INFO      => Logger::INFO,
 86 |             Zend_Log::DEBUG     => Logger::DEBUG,
 87 |         );
 88 |     }
 89 | 
 90 |     /**
 91 |      * Write a message using Monolog.
 92 |      *
 93 |      * @param  array $event  event data
 94 |      * @return void
 95 |      */
 96 |     protected function _write($event)
 97 |     {
 98 |         $level = $this->_levelMap[$event['priority']];
 99 |         $message = $event['message'];
100 |         $this->_logger->addRecord($level, $message);
101 |     }
102 | 
103 |     /**
104 |      * Create a new instance of Aleron75_Magemonolog_Model_Logwriter
105 |      *
106 |      * @param  array|Zend_Config $config
107 |      * @return Aleron75_Magemonolog_Model_Logwriter
108 |      * @throws Zend_Log_Exception
109 |      */
110 |     static public function factory($config)
111 |     {
112 |         return new self(self::_parseConfig($config));
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | magemonolog
  2 | ===========
  3 | 
  4 | Facts
  5 | -----
  6 | Version: 0.2.2
  7 | Developed (and tested) on Magento CE v 1.8.1.0
  8 | 
  9 | Introduction
 10 | ------------
 11 | 
 12 | A Magento extension which provides a custom writer model to transparently use 
 13 | Monolog as logging library.
 14 | 
 15 | The following Monolog's Handlers are supported at the moment:
 16 | 
 17 | * `StreamHandler` - writes to file
 18 | * `NativeMailHandler` - sends each log entry via email
 19 | * `NewRelicHandler` - logs in NewRelic app
 20 | 
 21 | Installation
 22 | ------------
 23 | 
 24 | You can install this extension in several ways:
 25 | 
 26 | **Download**
 27 | 
 28 | Download the full package, copy the content of the `app` directory
 29 | in your Magento base directory; pay attention not to overwrite
 30 | the `app` folder, only merge its contents into existing directory;
 31 | 
 32 | **Modman**
 33 | 
 34 | Install modman Module Manager: https://github.com/colinmollenhour/modman
 35 | 
 36 | After having installed modman on your system, you can clone this module on your
 37 | Magento base directory by typing the following command:
 38 | 
 39 |     $ modman init
 40 |     $ modman clone git@github.com:aleron75/magemonolog.git
 41 | 
 42 | **Composer**
 43 | 
 44 | Install composer: http://getcomposer.org/download/
 45 | 
 46 | Install Magento Composer: https://github.com/magento-hackathon/magento-composer-installer
 47 | 
 48 | Type the following command:
 49 | 
 50 |     $ php composer.phar require aleron75/magemonolog:dev-master
 51 | 
 52 | or
 53 | 
 54 |     $ composer require aleron75/magemonolog:dev-master
 55 | 
 56 | **Common tasks**
 57 | 
 58 | After installation:
 59 | 
 60 | * if you have cache enabled, disable or refresh it;
 61 | * if you have compilation enabled, disable it or recompile the code base.
 62 | 
 63 | Usage example
 64 | -------------
 65 | Once installed, the module automatically replaces the default Magento Log Writer
 66 | with Monolog's StreamHandler.
 67 | 
 68 | This is obtained through the following config node in `config.xml`:
 69 | 
 70 |     <config>
 71 |         <global>
 72 |             <log>
 73 |                 <core>
 74 |                     <writer_model>Aleron75_Magemonolog_Model_Logwriter</writer_model>
 75 |                 </core>
 76 |             </log>
 77 |         </global>
 78 |     </config>
 79 | 
 80 | which instructs Magento to use a custom log writer class when logging via the
 81 | `Mage::log()` native static function.
 82 | 
 83 | The configured `Aleron75_Magemonolog_Model_Logwriter` class is a wrapper for
 84 | Monolog and allows to use Monolog's Handlers.
 85 | 
 86 | Monolog's Handlers are configured in the `config.xml` through the following
 87 | config node:
 88 | 
 89 |     <config>
 90 |         <default>
 91 |             <magemonolog>
 92 |                 <handlers>
 93 |                     <StreamHandler>
 94 |                         <active>1</active>
 95 |                         <params>
 96 |                             <stream>magemonolog.log</stream>
 97 |                             <level>DEBUG</level>
 98 |                             <bubble>true</bubble>
 99 |                             <filePermission>null</filePermission>
100 |                             <useLocking>false</useLocking>
101 |                         </params>
102 |                     </StreamHandler>
103 |                     <NativeMailHandler>
104 |                         <active>0</active>
105 |                         <params>
106 |                             <to>dummy@example.com</to>
107 |                             <subject>Log</subject>
108 |                             <from>dummy@example.com</from>
109 |                             <level>ERROR</level>
110 |                             <bubble>true</bubble>
111 |                             <maxColumnWidth>70</maxColumnWidth>
112 |                         </params>
113 |                     </NativeMailHandler>
114 |                     <NewRelicHandler>
115 |                         <active>0</active>
116 |                         <params>
117 |                             <level>ERROR</level>
118 |                             <bubble>true</bubble>
119 |                             <appname>***your app name here***</appname>
120 |                         </params>
121 |                     </NewRelicHandler>
122 |                 </handlers>
123 |             </magemonolog>
124 |         </default>
125 |     </config>
126 | 
127 | It is assumed you know Monolog's Handlers to understand the meaning of `params`
128 | node.
129 | 
130 | Multiple Log Handlers can be activated at the same time with different log
131 | filter level; this way, for example, it is possible to log any message into a
132 | file and only serious errors via e-mail.
133 | 
134 | You can also use Monolog's Formatters like shown below:
135 | 
136 |     <config>
137 |         <default>
138 |             <magemonolog>
139 |                 <handlers>
140 |                     <StreamHandler>
141 |                         <active>1</active>
142 |                         <params>
143 |                             <stream>magemonolog.log</stream>
144 |                             <level>DEBUG</level>
145 |                             <bubble>true</bubble>
146 |                             <filePermission>null</filePermission>
147 |                             <useLocking>false</useLocking>
148 |                         </params>
149 |                         <formatter>
150 |                             <class>LogstashFormatter</class>
151 |                             <args>
152 |                                 <application_name><![CDATA[MyAppName]]></application_name>
153 |                                 <system_name><![CDATA[]]></system_name>
154 |                                 <extra_prefix><![CDATA[]]></extra_prefix>
155 |                                 <context_prefix><![CDATA[]]></context_prefix>
156 |                                 <version><![CDATA[]]></version>
157 |                             </args>
158 |                         </formatter>
159 |                     </StreamHandler>
160 |                 </handlers>
161 |             </magemonolog>
162 |         </default>
163 |     </config>
164 | 
165 | The `<args>` tag should contain proper Formatter's contructor arguments. Arguments' tag name is not important, values
166 | are passed to Formatter's constructor in the exact order the constructor requires them. You should consult Formatter's
167 | constructor signature to know which are its arguments, their meaning and their order.
168 | 
169 | Closing words
170 | -------------
171 | Any feedback is appreciated.
172 | 
173 | This extension is published under the [Open Software License (OSL 3.0)](http://opensource.org/licenses/OSL-3.0).
174 | 
175 | Any contribution or feedback is extremely appreciated.
176 | 


--------------------------------------------------------------------------------