PHP code example of wshafer / psr11-monolog

1. Go to this page and download the library: Download wshafer/psr11-monolog library. Choose the download type require.

2. Extract the ZIP file and open the index.php.

3. Add this code to the index.php.
    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

wshafer / psr11-monolog example snippets




# Get the Channel Changer
$channel = $container->get('my-channel');

# Write to log
$channel->debug('Hi There');

// Create Container
$container = new \Xtreamwayz\Pimple\Container([
    // Logger using the default keys.
    'logger' => new \WShafer\PSR11MonoLog\MonologFactory(),
    
    // Another logger using a different channel configuration
    'other' => function($c) {
        return \WShafer\PSR11MonoLog\MonologFactory::channelTwo($c);
    },

    'config' => [
        'monolog' => [
            'handlers' => [
                // At the bare minimum you must               'stream' => '/var/log/someother-log-file.txt',
                    ],
                ],
            ],
            
            'channels' => [
                // Configure a second channel
                'channelTwo' => [
                    'name' => 'MyOtherChannel',
                    'handlers' => [
                        'myOtherHandler',
                    ],
                ],    
            ],
        ],
    ],
]);

// Get the default channel

/** @var \Monolog\Logger $defaultChannel */
$defaultChannel = $container->get('logger');

// Write to the default channel
$defaultChannel->debug('Write to log');


// Get the second channel

/** @var \Monolog\Logger $channelTwo */
$channelTwo = $container->get('channelTwo');

// Write to the second channel
$channelTwo->debug('Write to log');



// Create the container and define the services you'd like to use
$container = new \Zend\ServiceManager\ServiceManager([
    'factories' => [
        // Logger using the default keys.
        'logger' => \WShafer\PSR11MonoLog\MonologFactory::class,
        
        // Another logger using a different channel configuration
        'channelTwo' => [\WShafer\PSR11MonoLog\MonologFactory::class, 'channelTwo']
    ]
]);

$container->setService(
    'config',
    [
        'monolog' => [
            'handlers' => [
                // At the bare minimum you must     ],
            
            'channels' => [
                // Configure a second channel
                'channelTwo' => [
                    'name' => 'MyOtherChannel',
                    'handlers' => [
                        'myOtherHandler',
                    ],
                ],    
            ],
        ],
    ]
);

// Get the default channel

/** @var \Monolog\Logger $defaultChannel */
$defaultChannel = $container->get('logger');

// Write to the default channel
$defaultChannel->debug('Write to log');


// Get the second channel

/** @var \Monolog\Logger $channelTwo */
$channelTwo = $container->get('channelTwo');

// Write to the second channel
$channelTwo->debug('Write to log');


return [
    'dependencies' => [
        'factories' => [
            // Logger using the default keys.
            'logger' => \WShafer\PSR11MonoLog\MonologFactory::class,
            
            // Another logger using a different channel configuration
            'channelTwo' => [\WShafer\PSR11MonoLog\MonologFactory::class, 'channelTwo']
        ]
    ],
    
    'monolog' => [
        'handlers' => [
            // At the bare minimum you must .txt',
                ],
            ],
        ],
        
        'channels' => [
            // Configure a second channel
            'channelTwo' => [
                'name' => 'MyOtherChannel',
                'handlers' => [
                    'myOtherHandler',
                ],
            ],    
        ],
    ],
];


return [
    'service_manager' => [
        'factories' => [
            // Logger using the default keys.
            'logger' => \WShafer\PSR11MonoLog\MonologFactory::class,
            
            // Another logger using a different channel configuration
            'channelTwo' => [\WShafer\PSR11MonoLog\MonologFactory::class, 'channelTwo']
        ]
    ],
    
    'monolog' => [
        'handlers' => [
            // At the bare minimum you must t',
                ],
            ],
        ],
        
        'channels' => [
            // Configure a second channel
            'channelTwo' => [
                'name' => 'MyOtherChannel',
                'handlers' => [
                    'myOtherHandler',
                ],
            ],    
        ],
    ],
];



return [
    // ... Previously registered modules here
    'WShafer\\PSR11MonoLog',
];



return [
    'modules' => [
        // ... Previously registered modules here
        'WShafer\\PSR11MonoLog',
    ]
];



return [
    'dependencies' => [
        'factories' => [
            // Logger using the default keys.
            'logger' => \WShafer\PSR11MonoLog\MonologFactory::class,
        ]
    ],
    
    'monolog' => [
        'handlers' => [
            'default' => [
                'type' => 'stream',
                'options' => [
                    'stream' => '/var/log/some-log-file.txt',
                ],
            ],
        ],
    ],
];



return [
    
    'dependencies' => [
        'factories' => [
            // Logger using the default keys.
            'logger' => \WShafer\PSR11MonoLog\MonologFactory::class,
            
            // Another logger using a different channel configuration
            'channelTwo' => [\WShafer\PSR11MonoLog\MonologFactory::class, 'channelTwo']
        ]
    ],
        
    'monolog' => [
        'formatters' => [
            // Array Keys are the names used for the formatters
            'formatterOne' => [
                // A formatter type or pre-configured service from the container
                'type' => 'line',
                
                // Formatter specific options.  See formatters below
                'options' => [
                    'format'                     => "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n",
                    'dateFormat'                 => "c",
                    'allowInlineLineBreaks'      => true,
                    'ignoreEmptyContextAndExtra' => false,
                ],
            ],
            
            'formatterTwo' => [
                // A formatter type or pre-configured service from the container
                'type' => 'line',
                
                // Formatter specific options.  See formatters below
                'options' => [
                    'format'                     => "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n",
                    'dateFormat'                 => "c",
                    'allowInlineLineBreaks'      => false,
                    'ignoreEmptyContextAndExtra' => true,
                ],
            ],
        ],
        
        'handlers' => [
            // Array Keys are the names used for the handlers
            'default' => [
                // A Handler type or pre-configured service from the container
                'type' => 'stream',
                
                // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'formatter' => 'formatterOne', 
                
                // Handler specific options.  See handlers below
                'options' => [
                    'stream' => '/tmp/log_one.txt',
                ], 
                'processors' => [
                    'my-handler-processor',
                ],
            ],
            
            'handlerTwo' => [
                // A Handler type or pre-configured service from the container
                'type' => 'stream', 
                
                // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'formatter' => 'formatterTwo', 
                
                // Adaptor specific options.  See adaptors below
                'options' => [
                    'stream' => '/tmp/log_two.txt',
                ], 
            ],
        ],
        
        'processors' => [
            // Array Keys are the names used for the processors
            'processorOne' => [
                // A processor type or pre-configured service from the container
                'type' => 'psrLogMessage',
                
                // processor specific options.  See processors below
                'options' => [], 
            ],
            
            'processorTwo' => [
                // A processor type or pre-configured service from the container
                'type' => 'uid',
                
                // processor specific options.  See processors below
                'options' => [
                    'length'  => 7,
                ], 
            ],
            'my-handler-processor' => [
                // A processor type or pre-configured service from the container
                'type' => 'psrLogMessage',
                
                // processor specific options.  See processors below
                'options' => [], 
            ],            
        ],
        
        'channels' => [
            // Array Keys are the names used for the channels
            //
            // Note: You can specify "default" here to overwrite the default settings for the
            // default channel.  If no handler is defined for default then the default 
            // handler will be used.
            'default' => [
                // Optional: Name of channel to show in logs.  Defaults to the array key
                'name' => 'MyAppChannel',
                
                // array of handlers to attach to the channel.  Can use multiple handlers if needed.
                'handlers' => ['handlerOne', 'handlerTwo'],
                
                // optional array of processors to attach to the channel.  Can use multiple processors if needed.
                'processors' => ['processorOne', 'processorTwo'],
            ],
            
            'channelTwo' => [
                // Optional: Name of channel to show in logs.  Defaults to the array key
                'name' => 'MyOtherChannel',
                
                // array of handlers to attach to the channel.  Can use multiple handlers if needed.
                'handlers' => ['handlerTwo'],
                
                // optional array of processors to attach to the channel.  Can use multiple processors if needed.
                'processors' => ['processorTwo'],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'channels' => [
            
            // Array Keys are the channel identifiers
            'myChannelName' => [
                // Optional: Name of channel to show in logs.  Defaults to the array key
                'name' => 'MyChannelLogName',
                                
                // Array of configured handlers.  See handlers for more info
                'handlers' => [  
                    'myHandler',  
                ],
                
                // Array of configured processors.  See processors for more info
                'processors' => [  
                    'myProcessor',  
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'stream',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'stream'         => '/tmp/stream_test.txt', // Required:  File Path | Resource | Service Name
                    'level'          => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'         => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'filePermission' => null, // Optional: file permissions (default (0644) are only for owner read/write)
                    'useLocking'     => false, // Optional: Try to lock log file before doing any writes
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'rotating',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'filename'       => '/tmp/stream_test.txt', // Required:  File Path
                    'maxFiles'       => 0, // Optional:  The maximal amount of files to keep (0 means unlimited)
                    'level'          => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'         => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'filePermission' => null, // Optional: file permissions (default (0644) are only for owner read/write)
                    'useLocking'     => false, // Optional: Try to lock log file before doing any writes
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'syslog',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'ident'          => '/tmp/stream_test.txt', // Required:  The string ident is added to each message. 
                    'facility'       => LOG_USER, // Optional:  The facility argument is used to specify what type of program is logging the message.
                    'level'          => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'         => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'logOpts'        => LOG_PID, // Optional: Option flags for the openlog() call, defaults to LOG_PID
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'errorlog',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'messageType'    => \Monolog\Handler\ErrorLogHandler::OPERATING_SYSTEM, // Optional:  Says where the error should go.
                    'level'          => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'         => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'expandNewlines' => false, // Optional: If set to true, newlines in the message will be expanded to be take multiple log entries
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'errorlog',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'command' => 'some-command', // Command for the process to start. Absolute paths are recommended, especially if you do not use the $cwd parameter.
                    'level'   => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'  => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'cwd'     => __DIR__, // Optional: "Current working directory" (CWD) for the process to be executed in.
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'nativeMailer',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'to'             => ['[email protected]', '[email protected]'], // The receiver of the mail. Can be an array or string
                    'subject'        => 'Error Log', // The subject of the mail
                    'from'           => '[email protected]', // The sender of the mail
                    'level'          => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'         => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'maxColumnWidth' => 80, // Optional: The maximum column width that the message lines will have
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'swiftMailer',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'mailer'  => 'my-service', // The mailer to use.  Must be a valid service name in the container
                    'message' => 'my-message', // An example message for real messages, only the body will be replaced.  Must be a valid service name or callable
                    'level'   => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'  => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'pushover',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'token'             => 'sometokenhere', // Pushover api token
                    'users'             => ['[email protected]', '[email protected]'], // Pushover user id or array of ids the message will be sent to
                    'title'             => 'Error Log', // Optional: Title sent to the Pushover API
                    'level'             => \Monolog\Logger::INFO, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'            => false, // Optional:  Whether the messages that are handled can bubble up the stack or not
                    'useSSL'            => false, // Optional:  Whether to connect via SSL. Required when pushing messages to users that are not the pushover.net app owner. OpenSSL is 



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'flowdock',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'apiToken' => 'sometokenhere', // HipChat API Token
                    'level'    => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'   => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'slackWebhook',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'webhookUrl'             => 'webhook.slack.com', // Slack Webhook URL
                    'channel'                => 'channel', // Slack channel (encoded ID or name)
                    'userName'               => 'Monolog', // Name of a bot
                    'useAttachment'          => false, // Optional: Whether the message should be added to Slack as attachment (plain text otherwise)
                    'iconEmoji'              => null, // Optional: The emoji name to use (or null)
                    'useShortAttachment'     => true, // Optional: Whether the the context/extra messages added to Slack as attachments are in a short style
                    '



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'slack',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'token     '             => 'apiToken', // Slack API token
                    'channel'                => 'channel', // Slack channel (encoded ID or name)
                    'userName'               => 'Monolog', // Name of a bot
                    'useAttachment'          => false, // Optional: Whether the message should be added to Slack as attachment (plain text otherwise)
                    'iconEmoji'              => null, // Optional: The emoji name to use (or null)
                    'useShortAttachment'     => true, // Optional: Whether the the context/extra messages added to Slack as attachments are in a short style
                    '



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'sendgrid',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'apiUser'                => 'apiUser', // The SendGrid API User
                    'apiKey'                 => 'apiKey', // The SendGrid API Key
                    'from'                   => 'from', // The sender of the email
                    'to'                     => 'to', // string or array of recipients
                    'subject'                => 'subject', // The subject of the mail
                    'level'                  => \Monolog\Logger::INFO, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'                 => false, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'mandrill',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'apiKey'  => 'my-service', // A valid Mandrill API key
                    'message' => 'my-message', // An example \Swiftmail message for real messages, only the body will be replaced.  Must be a valid service name or callable
                    'level'   => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'  => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'fleepHook',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'token'  => 'sometokenhere', // Webhook token
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'telegrambot',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'apiKey' => 'api-key', // Api Key
                    'channel' => 'api-key', // Channel
                    'level'    => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'   => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'socket',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'connectionString' => 'unix:///var/log/httpd_app_log.socket', // Socket connection string.  You can use a unix:// prefix to access unix sockets and udp:// to open UDP sockets instead of the default TCP.
                    'timeout'          => 30, // Optional: The connection timeout, in seconds.
                    'writeTimeout'     => 90, // Optional: Set timeout period on a stream.
                    'level'            => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'           => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'amqp',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'exchange'     => 'my-service', // AMQPExchange (php AMQP ext) or PHP AMQP lib channel.  Must be a valid service.
                    'exchangeName' => 'log-name', // Optional: Exchange name, for AMQPChannel (PhpAmqpLib) only
                    'level'        => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'       => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'gelf',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'publisher' => 'my-service', // A Gelf\PublisherInterface object.  Must be a valid service.
                    'level'     => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'    => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'cube',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'url'    => 'http://test.com:80', // A valid url.  Must consist of three parts : protocol://host:port
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'zend',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'newRelic',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'level'           => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'          => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'appName'         => 'my-app', // Optional: Application name
                    'explodeArrays'   => 'false', // Optional: Explode Arrays
                    'transactionName' => 'my-transaction', // Optional: Explode Arrays
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'loggly',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'token'  => 'sometokenhere', // Webhook token
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'syslogUdp',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'host'     => 'somewhere.com', // Host
                    'port'     => 513, //  Optional: Port
                    'facility' => 'Me', // Optional: Facility
                    'level'    => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'   => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'ident'    => 'me-too', // Optional: Program name or tag for each log message.
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'logEntries',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'token'  => 'sometokenhere', // Log token supplied by LogEntries
                    'useSSL' => true, // Optional: Whether or not SSL encryption should be used.
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'insightops',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'token'  => 'sometokenhere', // Log token supplied by InsightOps
                    'region' => 'region', // Region where InsightOps account is hosted. Could be 'us' or 'eu'.
                    'useSSL' => true, // Optional: Whether or not SSL encryption should be used.
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'logmatic',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'token'  => 'sometokenhere', // Log token supplied by Logmatic.
                    'hostname' => 'region', //  Optional: Host name supplied by Logmatic.
                    'appname' => 'region', //  Optional: Application name supplied by Logmatic.
                    'useSSL' => true, // Optional: Whether or not SSL encryption should be used.
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'sqs',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'sqsClient' => 'my-service', // SQS Client.  Must be a valid service name in the container.
                    'queueUrl'  => 'url', // URL to SQS Queue
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'firePHP',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'chromePHP',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'browserConsole',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'phpConsole',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'options' => [], // Optional: See \Monolog\Handler\PHPConsoleHandler::$options for more details
                    'connector' => 'my-service', // Optional:  Instance of \PhpConsole\Connector class. Must be a valid service.
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'redis',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'client'  => 'my-redis-service-name', // The redis instance.  Must be either a [Predis] client OR a Pecl Redis instance
                    'key'     => 'my-service', // The key name to push records to
                    'level'   => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'  => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'capSize' => true, // Optional: Number of entries to limit list size to, 0 = unlimited
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'mongo',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'client'     => 'my-mongo-service-name', // MongoDB library or driver instance.
                    'database'   => 'my-db', // Database name
                    'collection' => 'collectionName', // Collection name
                    'level'      => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'     => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                    'capSize'    => true, // Optional: Number of entries to limit list size to, 0 = unlimited
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'couchDb',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'host'     => 'localhost',  // Optional: Hostname/Ip address,  Default: 'localhost'
                    'port'     => 5984, // Optional: port,  Default: 5984
                    'dbname'   => 'db', // Optional: Database Name,  Default: 'logger'
                    'username' => 'someuser', // Optional: Username,  Default: null
                    'password' => 'somepass', // Optional: Password,  Default: null
                    'level'    => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'   => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'doctrineCouchDb',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'client' => 'my-service', //  CouchDBClient service name.  Must be a valid container service
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'elastica',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'client'      => 'my-service', //  Elastica Client object.  Must be a valid container service
                    'index'       => 'monolog', // Optional: Elastic index name
                    'type'        => 'record', // Optional: Elastic document type
                    'ignoreError' => false, // Optional: Suppress Elastica exceptions
                    'level'       => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'      => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'dynamoDb',
                'formatter' => 'formatterName', // Optional: Formatter for the handler.  Default for the handler will be used if not supplied
                'options' => [
                    'client'      => 'my-service', //  DynamoDbClient object.  Must be a valid container service
                    'table'       => 'monolog', // Table name
                    'level'       => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'      => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'fingersCrossed',
                'options' => [
                    'handler'            => 'my-handler', // Required: Registered Handler to wrap
                    'activationStrategy' => 'my-service', // Optional: Strategy which determines when this handler takes action.  Must be either the error level or configured ActivationStrategyInterface service
                    'bufferSize'         => 0,            // Optional: How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
                    'bubble'             => true,         // Optional: Whether the messages that are handled can bubble up the stack or not
                    'stopBuffering'      => true,         // Optional: Whether the handler should stop buffering after being triggered (default true)
                    'passthruLevel'      => null,         // Optional: Minimum level to always flush to handler on close, even if strategy not triggered
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'deduplication',
                'options' => [
                    'handler'            => 'my-handler',           // Required: Registered Handler to wrap
                    'deduplicationStore' => '/tmp/somestore',       // Optional: The file/path where the deduplication log should be kept
                    'deduplicationLevel' => \Monolog\Logger::ERROR, // Optional:The minimum logging level for log records to be looked at for deduplication purposes
                    'time'               => 60,                     // Optional: The period (in seconds) during which duplicate entries should be suppressed after a given log is sent through
                    'bubble'             => true,                   // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'whatFailureGroup',
                'options' => [
                    'handlers' => ['my-handler-one'. 'my-handler-two'], // Required: Array of Registered Handlers to wrap
                    'bubble'   => true,                                 // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'fallbackgroup',
                'options' => [
                    'handlers' => ['my-handler-one'. 'my-handler-two'], // Required: Array of Registered Handlers to wrap
                    'bubble'   => true,                                 // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'buffer',
                'options' => [
                    'handler'         => 'my-handler',           // Required: Registered Handler to wrap
                    'bufferLimit'     => 0,                      // Optional: How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
                    'level'           => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'          => true,                   // Optional: Whether the messages that are handled can bubble up the stack or not
                    'flushOnOverflow' => false,                  // Optional: If true, the buffer is flushed when the max size has been reached, by default oldest entries are discarded
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'group',
                'options' => [
                    'handlers' => ['my-handler-one'. 'my-handler-two'], // Required: Array of Registered Handlers to wrap
                    'bubble'   => true,                                 // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'filter',
                'options' => [
                    'handler'         => 'my-handler',               // Required: Registered Handler to wrap
                    'minLevelOrList'  => \Monolog\Logger::DEBUG,     // Optional: An array of levels to accept or a minimum level if maxLevel is provided
                    'maxLevel'        => \Monolog\Logger::EMERGENCY, // Optional: Maximum level to accept, only used if $minLevelOrList is not an array
                    'bubble'          => true,                       // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'sampling',
                'options' => [
                    'handler' => 'my-handler', // Required: Registered Handler to wrap
                    'factor'  => 5,            // Required: Sample factor
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type'    => 'noop',
                'options' => [],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type'    => 'noop',
                'options' => [
                    'level' => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type'    => 'psr',
                'options' => [
                    'logger' => 'loggerService',        // Required: Logger Service to wrap from the container
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true,                   // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type'    => 'test',
                'options' => [
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble' => true,                   // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'handlers' => [
            'myHandlerName' => [
                'type' => 'overflow',
                'options' => [
                    'handlers' => 'my-handler', // Required: Registered Handler to wrap
                    'thresholdMap' => [  // Optional: threshold map
                        'debug' => 2, // Optional: debug threshold.  Default: 0
                        'info' => 2, // Optional: info threshold.  Default: 0
                        'notice' => 2, // Optional: notice threshold.  Default: 0
                        'warning' => 2, // Optional: warning threshold.  Default: 0
                        'error' => 2, // Optional: error threshold.  Default: 0
                        'critical' => 2, // Optional: critical threshold.  Default: 0
                        'alert' => 2, // Optional: alert threshold.  Default: 0
                        'emergency' => 2, // Optional: emergency threshold.  Default: 0
                    ],
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this handler will be triggered
                    'bubble'   => true, // Optional: Whether the messages that are handled can bubble up the stack or not
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'line',
                'options' => [
                    'format'                     => "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n",  // Optional
                    'dateFormat'                 => "c", // Optional : The format of the timestamp: one supported by DateTime::format
                    'allowInlineLineBreaks'      => false, // Optional : Whether to allow inline line breaks in log entries
                    'ignoreEmptyContextAndExtra' => false, // Optional
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'html',
                'options' => [
                    'dateFormat' => "c", // Optional
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'normalizer',
                'options' => [
                    'dateFormat' => "c", // Optional
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'scalar',
                'options' => [], // No options available
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'json',
                'options' => [
                    'batchMode'     => \Monolog\Formatter\JsonFormatter::BATCH_MODE_JSON, //optional
                    'appendNewline' => true, //optional
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'wildfire',
                'options' => [
                    'dateFormat' => "c", // Optional
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'chromePHP',
                'options' => [], // No options available
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'gelf',
                'options' => [
                    'systemName'    => "my-system",  // Optional : the name of the system for the Gelf log message, defaults to the hostname of the machine
                    'extraPrefix'   => "extra_", // Optional : a prefix for 'extra' fields from the Monolog record
                    'contextPrefix' => 'ctxt_', // Optional : a prefix for 'context' fields from the Monolog record
                    'maxLength'     => 32766, // Optional : Length per field
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'logstash',
                'options' => [
                    'applicationName' => 'app-name', // the application that sends the data, used as the "type" field of logstash
                    'systemName'      => "my-system",  // Optional : the system/machine name, used as the "source" field of logstash, defaults to the hostname of the machine
                    'extraPrefix'     => "extra_", // Optional : prefix for extra keys inside logstash "fields"
                    'contextPrefix'   => 'ctxt_', // Optional : prefix for context keys inside logstash "fields", defaults to ctxt_
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'ElasticaFormatter' => [
                'type' => 'elastica',
                'options' => [
                    'index'   => 'some-index', // Elastic search index name
                    'type'    => "doc-type",  // Elastic search document type
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'loggly',
                'options' => [
                    'batchMode'     => \Monolog\Formatter\JsonFormatter::BATCH_MODE_NEWLINES, //optional
                    'appendNewline' => false, //optional
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'flowdock',
                'options' => [
                    'source'      => 'Some Source',
                    'sourceEmail' => '[email protected]'
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'mongodb',
                'options' => [
                    'maxNestingLevel'        => 3, // optional : 0 means infinite nesting, the $record itself is level 1, $record['context'] is 2
                    'exceptionTraceAsString' => true, // optional : set to false to log exception traces as a sub documents instead of strings
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'formatters' => [
            'myFormatterName' => [
                'type' => 'json',
                'options' => [
                    'batchMode'     => \Monolog\Formatter\LogmaticFormatter::BATCH_MODE_JSON, //optional
                    'appendNewline' => true, //optional
                    'hostname' => 'my-host', //optional 'hostname' parameter for indexing by Logmatic
                    'appName' => 'app name', //optional 'appname' parameter for indexing by Logmatic
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'psrLogMessage',
                'options' => [], // No options
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'introspection',
                'options' => [
                    'level'                => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this processor will be triggered
                    'skipClassesPartials'  => [], // Optional
                    'skipStackFramesCount' => 0, // Optional
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'web',
                'options' => [
                    'serverData'  => 'my-service', // Optional: Array, object w/ ArrayAccess, or valid service name that provides access to the $_SERVER data
                    'extraFields' => [], // Optional: Field names and the related key inside $serverData to be added. If not provided it defaults to: url, ip, http_method, server, referrer
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'memoryUsage',
                'options' => [], // No options
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'memoryPeak',
                'options' => [], // No options
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'processId',
                'options' => [], // No options
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'uid',
                'options' => [
                    'length'  => 7, // Optional: The uid length. Must be an integer between 1 and 32
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'git',
                'options' => [
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this processor will be triggered
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'mercurial',
                'options' => [
                    'level'  => \Monolog\Logger::DEBUG, // Optional: The minimum logging level at which this processor will be triggered
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'tags',
                'options' => [
                    'tags'  => [], // Optional: Array of tags to add to records
                ],
            ],
        ],
    ],
];



return [
    'monolog' => [
        'processors' => [
            'myProcessorsName' => [
                'type' => 'hostname',
                'options' => [], // No options
            ],
        ],
    ],
];