fix bug

api/Appapi/Api/Charge.php

@@ -94,11 +94,11 @@ class Api_Charge extends PhalApi_Api {
             return $rs;
         }
         $wx_config = [
-            'appid'       => $configpri['wx_appid'],
-            'appSecret'   => $configpri['wx_appsecret'],
-            'mch_id'      => $configpri['wx_mchid'],
-            'key'         => $configpri['wx_key'],
-            'notify_url'  => $configpub['site'].'/index.php?g=Appapi&m=pay&a=notify_wx',
+            'appid'       => 'wxa6bcebff7f4c5a3f',
+            'appSecret'   => '4b7d6cd67fc566659fd1d9bd399dbcba',
+            'mch_id'      => '1582052881',
+            'key'         => 'XCthxXszMdXiybUZnJBxyVgyVnV4zPuQ',
+            'notify_url'  => 'http://www.seals-live.com/index.php?g=Appapi&m=pay&a=notify_wx',
             'log' => [ // optional
                 'file' => dirname(dirname(dirname(__DIR__))) . '/wechat.log',
                 'level' => 'info', // 建议生产环境等级调整为 info，开发环境为 debug
@@ -107,7 +107,7 @@ class Api_Charge extends PhalApi_Api {
             ],
         ];
 
-        require dirname(dirname(dirname(__DIR__))) . '/vendor/autoload.php';
+//        require dirname(dirname(dirname(__DIR__))) . '/vendor/autoload.php';
         $wx = \Yansongda\Pay\Pay::wechat($wx_config);
         var_dump($wx_config, $wx);
         die;

composer.json

 {
     "require": {
-        "yansongda/pay": "^2.9"
+        "yansongda/pay": "2.7.8"
     }
 }

vendor/composer/autoload_psr4.php

@@ -17,7 +17,6 @@ return array(
     'Symfony\\Component\\EventDispatcher\\' => array($vendorDir . '/symfony/event-dispatcher'),
     'Psr\\Log\\' => array($vendorDir . '/psr/log/Psr/Log'),
     'Psr\\Http\\Message\\' => array($vendorDir . '/psr/http-message/src'),
-    'Psr\\EventDispatcher\\' => array($vendorDir . '/psr/event-dispatcher/src'),
     'Monolog\\' => array($vendorDir . '/monolog/monolog/src/Monolog'),
     'GuzzleHttp\\Psr7\\' => array($vendorDir . '/guzzlehttp/psr7/src'),
     'GuzzleHttp\\Promise\\' => array($vendorDir . '/guzzlehttp/promises/src'),

vendor/composer/autoload_static.php

@@ -36,7 +36,6 @@ class ComposerStaticInit6ca204ee4b311fba144444fd09f9bb55
         array (
             'Psr\\Log\\' => 8,
             'Psr\\Http\\Message\\' => 17,
-            'Psr\\EventDispatcher\\' => 20,
         ),
         'M' => 
         array (
@@ -95,10 +94,6 @@ class ComposerStaticInit6ca204ee4b311fba144444fd09f9bb55
         array (
             0 => __DIR__ . '/..' . '/psr/http-message/src',
         ),
-        'Psr\\EventDispatcher\\' => 
-        array (
-            0 => __DIR__ . '/..' . '/psr/event-dispatcher/src',
-        ),
         'Monolog\\' => 
         array (
             0 => __DIR__ . '/..' . '/monolog/monolog/src/Monolog',

vendor/monolog/monolog/CHANGELOG.md

-### 2.0.2 (2019-12-20)
-
-  * Fixed ElasticsearchHandler swallowing exceptions details when failing to index log records
-  * Fixed normalization of SoapFault objects containing non-strings as "detail" in LineFormatter
-  * Fixed formatting of resources in JsonFormatter
-  * Fixed RedisHandler failing to use MULTI properly when passed a proxied Redis instance (e.g. in Symfony with lazy services)
-  * Fixed FilterHandler triggering a notice when handleBatch was filtering all records passed to it
-  * Fixed Turkish locale messing up the conversion of level names to their constant values
-
-### 2.0.1 (2019-11-13)
-
-  * Fixed normalization of Traversables to avoid traversing them as not all of them are rewindable
-  * Fixed setFormatter/getFormatter to forward to the nested handler in FilterHandler, FingersCrossedHandler, BufferHandler, OverflowHandler and SamplingHandler
-  * Fixed BrowserConsoleHandler formatting when using multiple styles
-  * Fixed normalization of exception codes to be always integers even for PDOException which have them as numeric strings
-  * Fixed normalization of SoapFault objects containing non-strings as "detail"
-  * Fixed json encoding across all handlers to always attempt recovery of non-UTF-8 strings instead of failing the whole encoding
-  * Fixed ChromePHPHandler to avoid sending more data than latest Chrome versions allow in headers (4KB down from 256KB).
-  * Fixed type error in BrowserConsoleHandler when the context array of log records was not associative.
-
-### 2.0.0 (2019-08-30)
-
-  * BC Break: This is a major release, see [UPGRADE.md](UPGRADE.md) for details if you are coming from a 1.x release
-  * BC Break: Logger methods log/debug/info/notice/warning/error/critical/alert/emergency now have explicit void return types
-  * Added FallbackGroupHandler which works like the WhatFailureGroupHandler but stops dispatching log records as soon as one handler accepted it
-  * Fixed support for UTF-8 when cutting strings to avoid cutting a multibyte-character in half
-  * Fixed normalizers handling of exception backtraces to avoid serializing arguments in some cases
-  * Fixed date timezone handling in SyslogUdpHandler
-
-### 2.0.0-beta2 (2019-07-06)
-
-  * BC Break: This is a major release, see [UPGRADE.md](UPGRADE.md) for details if you are coming from a 1.x release
-  * BC Break: PHP 7.2 is now the minimum required PHP version.
-  * BC Break: Removed SlackbotHandler, RavenHandler and HipChatHandler, see [UPGRADE.md](UPGRADE.md) for details
-  * Added OverflowHandler which will only flush log records to its nested handler when reaching a certain amount of logs (i.e. only pass through when things go really bad)
-  * Added TelegramBotHandler to log records to a [Telegram](https://core.telegram.org/bots/api) bot account
-  * Added support for JsonSerializable when normalizing exceptions
-  * Added support for RFC3164 (outdated BSD syslog protocol) to SyslogUdpHandler
-  * Added SoapFault details to formatted exceptions
-  * Fixed DeduplicationHandler silently failing to start when file could not be opened
-  * Fixed issue in GroupHandler and WhatFailureGroupHandler where setting multiple processors would duplicate records
-  * Fixed GelfFormatter losing some data when one attachment was too long
-  * Fixed issue in SignalHandler restarting syscalls functionality
-  * Improved performance of LogglyHandler when sending multiple logs in a single request
-
-### 2.0.0-beta1 (2018-12-08)
-
-  * BC Break: This is a major release, see [UPGRADE.md](UPGRADE.md) for details if you are coming from a 1.x release
-  * BC Break: PHP 7.1 is now the minimum required PHP version.
-  * BC Break: Quite a few interface changes, only relevant if you implemented your own handlers/processors/formatters
-  * BC Break: Removed non-PSR-3 methods to add records, all the `add*` (e.g. `addWarning`) methods as well as `emerg`, `crit`, `err` and `warn`
-  * BC Break: The record timezone is now set per Logger instance and not statically anymore
-  * BC Break: There is no more default handler configured on empty Logger instances
-  * BC Break: ElasticSearchHandler renamed to ElasticaHandler
-  * BC Break: Various handler-specific breaks, see [UPGRADE.md](UPGRADE.md) for details
-  * Added scalar type hints and return hints in all the places it was possible. Switched strict_types on for more reliability.
-  * Added DateTimeImmutable support, all record datetime are now immutable, and will toString/json serialize with the correct date format, including microseconds (unless disabled)
-  * Added timezone and microseconds to the default date format
-  * Added SendGridHandler to use the SendGrid API to send emails
-  * Added LogmaticHandler to use the Logmatic.io API to store log records
-  * Added SqsHandler to send log records to an AWS SQS queue
-  * Added ElasticsearchHandler to send records via the official ES library. Elastica users should now use ElasticaHandler instead of ElasticSearchHandler
-  * Added NoopHandler which is similar to the NullHandle but does not prevent the bubbling of log records to handlers further down the configuration, useful for temporarily disabling a handler in configuration files
-  * Added ProcessHandler to write log output to the STDIN of a given process
-  * Added HostnameProcessor that adds the machine's hostname to log records
-  * Added a `$dateFormat` option to the PsrLogMessageProcessor which lets you format DateTime instances nicely
-  * Added support for the PHP 7.x `mongodb` extension in the MongoDBHandler
-  * Fixed many minor issues in various handlers, and probably added a few regressions too
-
 ### 1.25.3 (2019-12-20)
 
   * Fixed formatting of resources in JsonFormatter
@@ -108,7 +39,7 @@
   * Added a way to log signals being received using Monolog\SignalHandler
   * Added ability to customize error handling at the Logger level using Logger::setExceptionHandler
   * Added InsightOpsHandler to migrate users of the LogEntriesHandler
-  * Added protection to NormalizerFormatter against circular and very deep structures, it now stops normalizing at a depth of 9
+  * Added protection to NormalizerHandler against circular and very deep structures, it now stops normalizing at a depth of 9
   * Added capture of stack traces to ErrorHandler when logging PHP errors
   * Added RavenHandler support for a `contexts` context or extra key to forward that to Sentry's contexts
   * Added forwarding of context info to FluentdFormatter
@@ -148,7 +79,7 @@
   * Added SlackbotHandler and SlackWebhookHandler to set up Slack integration more easily
   * Added MercurialProcessor to add mercurial revision and branch names to log records
   * Added support for AWS SDK v3 in DynamoDbHandler
-  * Fixed fatal errors occurring when normalizing generators that have been fully consumed
+  * Fixed fatal errors occuring when normalizing generators that have been fully consumed
   * Fixed RollbarHandler to include a level (rollbar level), monolog_level (original name), channel and datetime (unix)
   * Fixed RollbarHandler not flushing records automatically, calling close() explicitly is not necessary anymore
   * Fixed SyslogUdpHandler to avoid sending empty frames
@@ -158,7 +89,7 @@
 
   * Break: Reverted the addition of $context when the ErrorHandler handles regular php errors from 1.20.0 as it was causing issues
   * Added support for more formats in RotatingFileHandler::setFilenameFormat as long as they have Y, m and d in order
-  * Added ability to format the main line of text the SlackHandler sends by explicitly setting a formatter on the handler
+  * Added ability to format the main line of text the SlackHandler sends by explictly setting a formatter on the handler
   * Added information about SoapFault instances in NormalizerFormatter
   * Added $handleOnlyReportedErrors option on ErrorHandler::registerErrorHandler (default true) to allow logging of all errors no matter the error_reporting level
 
@@ -280,7 +211,7 @@
   * Added $useShortAttachment to SlackHandler to minify attachment size and $includeExtra to append extra data
   * Added $host to HipChatHandler for users of private instances
   * Added $transactionName to NewRelicHandler and support for a transaction_name context value
-  * Fixed MandrillHandler to avoid outputting API call responses
+  * Fixed MandrillHandler to avoid outputing API call responses
   * Fixed some non-standard behaviors in SyslogUdpHandler
 
 ### 1.11.0 (2014-09-30)

vendor/monolog/monolog/LICENSE

-Copyright (c) 2011-2019 Jordi Boggiano
+Copyright (c) 2011-2016 Jordi Boggiano
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

vendor/monolog/monolog/README.md

-# Monolog - Logging for PHP [![Build Status](https://travis-ci.org/Seldaek/monolog.svg?branch=master)](https://travis-ci.org/Seldaek/monolog)
+# Monolog - Logging for PHP [![Build Status](https://img.shields.io/travis/Seldaek/monolog.svg)](https://travis-ci.org/Seldaek/monolog)
 
 [![Total Downloads](https://img.shields.io/packagist/dt/monolog/monolog.svg)](https://packagist.org/packages/monolog/monolog)
 [![Latest Stable Version](https://img.shields.io/packagist/v/monolog/monolog.svg)](https://packagist.org/packages/monolog/monolog)
@@ -36,23 +36,16 @@ $log = new Logger('name');
 $log->pushHandler(new StreamHandler('path/to/your.log', Logger::WARNING));
 
 // add records to the log
-$log->warning('Foo');
-$log->error('Bar');
+$log->addWarning('Foo');
+$log->addError('Bar');
 ```
 
 ## Documentation
 
 - [Usage Instructions](doc/01-usage.md)
 - [Handlers, Formatters and Processors](doc/02-handlers-formatters-processors.md)
-- [Utility Classes](doc/03-utilities.md)
+- [Utility classes](doc/03-utilities.md)
 - [Extending Monolog](doc/04-extending.md)
-- [Log Record Structure](doc/message-structure.md)
-
-## Support Monolog Financially
-
-Get supported Monolog and help fund the project with the [Tidelift Subscription](https://tidelift.com/subscription/pkg/packagist-monolog-monolog?utm_source=packagist-monolog-monolog&utm_medium=referral&utm_campaign=enterprise) or via [GitHub sponsorship](https://github.com/sponsors/Seldaek). 
-
-Tidelift delivers commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use.
 
 ## Third Party Packages
 
@@ -64,7 +57,7 @@ can also add your own there if you publish one.
 
 ### Requirements
 
-- Monolog 2.x works with PHP 7.2 or above, use Monolog `^1.0` for PHP 5.3+ support.
+- Monolog works with PHP 5.3 or above, and is also tested to work with HHVM.
 
 ### Submitting bugs and feature requests
 
@@ -74,26 +67,22 @@ Bugs and feature request are tracked on [GitHub](https://github.com/Seldaek/mono
 
 - Frameworks and libraries using [PSR-3](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md)
   can be used very easily with Monolog since it implements the interface.
-- [Symfony](http://symfony.com) comes out of the box with Monolog.
-- [Laravel](http://laravel.com/) comes out of the box with Monolog.
+- [Symfony2](http://symfony.com) comes out of the box with Monolog.
+- [Silex](http://silex.sensiolabs.org/) comes out of the box with Monolog.
+- [Laravel 4 & 5](http://laravel.com/) come out of the box with Monolog.
 - [Lumen](http://lumen.laravel.com/) comes out of the box with Monolog.
-- [PPI](https://github.com/ppi/framework) comes out of the box with Monolog.
+- [PPI](http://www.ppi.io/) comes out of the box with Monolog.
 - [CakePHP](http://cakephp.org/) is usable with Monolog via the [cakephp-monolog](https://github.com/jadb/cakephp-monolog) plugin.
 - [Slim](http://www.slimframework.com/) is usable with Monolog via the [Slim-Monolog](https://github.com/Flynsarmy/Slim-Monolog) log writer.
 - [XOOPS 2.6](http://xoops.org/) comes out of the box with Monolog.
 - [Aura.Web_Project](https://github.com/auraphp/Aura.Web_Project) comes out of the box with Monolog.
 - [Nette Framework](http://nette.org/en/) can be used with Monolog via [Kdyby/Monolog](https://github.com/Kdyby/Monolog) extension.
 - [Proton Micro Framework](https://github.com/alexbilbie/Proton) comes out of the box with Monolog.
-- [FuelPHP](http://fuelphp.com/) comes out of the box with Monolog.
-- [Equip Framework](https://github.com/equip/framework) comes out of the box with Monolog.
-- [Yii 2](http://www.yiiframework.com/) is usable with Monolog via the [yii2-monolog](https://github.com/merorafael/yii2-monolog) or [yii2-psr-log-target](https://github.com/samdark/yii2-psr-log-target) plugins.
-- [Hawkbit Micro Framework](https://github.com/HawkBitPhp/hawkbit) comes out of the box with Monolog.
-- [SilverStripe 4](https://www.silverstripe.org/) comes out of the box with Monolog.
 
 ### Author
 
 Jordi Boggiano - <j.boggiano@seld.be> - <http://twitter.com/seldaek><br />
-See also the list of [contributors](https://github.com/Seldaek/monolog/contributors) who participated in this project.
+See also the list of [contributors](https://github.com/Seldaek/monolog/contributors) which participated in this project.
 
 ### License
 

vendor/monolog/monolog/UPGRADE.md

-### 2.0.0
-
-- `Monolog\Logger::API` can be used to distinguish between a Monolog `1` and `2`
-  install of Monolog when writing integration code.
-
-- Removed non-PSR-3 methods to add records, all the `add*` (e.g. `addWarning`)
-  methods as well as `emerg`, `crit`, `err` and `warn`.
-
-- DateTime are now formatted with a timezone and microseconds (unless disabled).
-  Various formatters and log output might be affected, which may mess with log parsing
-  in some cases.
-
-- The `datetime` in every record array is now a DateTimeImmutable, not that you
-  should have been modifying these anyway.
-
-- The timezone is now set per Logger instance and not statically, either
-  via ->setTimezone or passed in the constructor. Calls to Logger::setTimezone
-  should be converted.
-
-- `HandlerInterface` has been split off and two new interfaces now exist for
-  more granular controls: `ProcessableHandlerInterface` and
-  `FormattableHandlerInterface`. Handlers not extending `AbstractHandler`
-  should make sure to implement the relevant interfaces.
-
-- `HandlerInterface` now requires the `close` method to be implemented. This
-  only impacts you if you implement the interface yourself, but you can extend
-  the new `Monolog\Handler\Handler` base class too.
-
-- There is no more default handler configured on empty Logger instances, if
-  you were relying on that you will not get any output anymore, make sure to
-  configure the handler you need.
-
-#### LogglyFormatter
-
-- The records' `datetime` is not sent anymore. Only `timestamp` is sent to Loggly.
-
-#### AmqpHandler
-
-- Log levels are not shortened to 4 characters anymore. e.g. a warning record
-  will be sent using the `warning.channel` routing key instead of `warn.channel`
-  as in 1.x.
-- The exchange name does not default to 'log' anymore, and it is completely ignored
-  now for the AMQP extension users. Only PHPAmqpLib uses it if provided.
-
-#### RotatingFileHandler
-
-- The file name format must now contain `{date}` and the date format must be set
-  to one of the predefined FILE_PER_* constants to avoid issues with file rotation.
-  See `setFilenameFormat`.
-
-#### LogstashFormatter
-
-- Removed Logstash V0 support
-- Context/extra prefix has been removed in favor of letting users configure the exact key being sent
-- Context/extra data are now sent as an object instead of single keys
-
-#### HipChatHandler
-
-- Removed deprecated HipChat handler, migrate to Slack and use SlackWebhookHandler or SlackHandler instead
-
-#### SlackbotHandler
-
-- Removed deprecated SlackbotHandler handler, use SlackWebhookHandler or SlackHandler instead
-
-#### RavenHandler
-
-- Removed deprecated RavenHandler handler, use sentry/sentry 2.x and their Sentry\Monolog\Handler instead
-
-#### ElasticSearchHandler
-
-- As support for the official Elasticsearch library was added, the former ElasticSearchHandler has been
-  renamed to ElasticaHandler and the new one added as ElasticsearchHandler.

vendor/monolog/monolog/composer.json

@@ -13,37 +13,35 @@
         }
     ],
     "require": {
-        "php": "^7.2",
-        "psr/log": "^1.0.1"
+        "php": ">=5.3.0",
+        "psr/log": "~1.0"
     },
     "require-dev": {
-        "aws/aws-sdk-php": "^2.4.9 || ^3.0",
+        "phpunit/phpunit": "~4.5",
+        "graylog2/gelf-php": "~1.0",
+        "sentry/sentry": "^0.13",
+        "ruflin/elastica": ">=0.90 <3.0",
         "doctrine/couchdb": "~1.0@dev",
-        "elasticsearch/elasticsearch": "^6.0",
-        "graylog2/gelf-php": "^1.4.2",
-        "jakub-onderka/php-parallel-lint": "^0.9",
+        "aws/aws-sdk-php": "^2.4.9 || ^3.0",
         "php-amqplib/php-amqplib": "~2.4",
+        "swiftmailer/swiftmailer": "^5.3|^6.0",
         "php-console/php-console": "^3.1.3",
-        "phpspec/prophecy": "^1.6.1",
-        "phpunit/phpunit": "^8.3",
-        "predis/predis": "^1.1",
-        "rollbar/rollbar": "^1.3",
-        "ruflin/elastica": ">=0.90 <3.0",
-        "swiftmailer/swiftmailer": "^5.3|^6.0"
+        "phpunit/phpunit-mock-objects": "2.3.0",
+        "jakub-onderka/php-parallel-lint": "0.9"
     },
+    "_": "phpunit/phpunit-mock-objects required in 2.3.0 due to https://github.com/sebastianbergmann/phpunit-mock-objects/issues/223 - needs hhvm 3.8+ on travis",
     "suggest": {
         "graylog2/gelf-php": "Allow sending log messages to a GrayLog2 server",
+        "sentry/sentry": "Allow sending log messages to a Sentry server",
         "doctrine/couchdb": "Allow sending log messages to a CouchDB server",
         "ruflin/elastica": "Allow sending log messages to an Elastic Search server",
-        "elasticsearch/elasticsearch": "Allow sending log messages to an Elasticsearch server via official client",
         "php-amqplib/php-amqplib": "Allow sending log messages to an AMQP server using php-amqplib",
         "ext-amqp": "Allow sending log messages to an AMQP server (1.0+ required)",
-        "ext-mongodb": "Allow sending log messages to a MongoDB server (via driver)",
-        "mongodb/mongodb": "Allow sending log messages to a MongoDB server (via library)",
+        "ext-mongo": "Allow sending log messages to a MongoDB server",
+        "mongodb/mongodb": "Allow sending log messages to a MongoDB server via PHP Driver",
         "aws/aws-sdk-php": "Allow sending log messages to AWS services like DynamoDB",
         "rollbar/rollbar": "Allow sending log messages to Rollbar",
-        "php-console/php-console": "Allow sending log messages to Google Chrome",
-        "ext-mbstring": "Allow to work properly with unicode symbols"
+        "php-console/php-console": "Allow sending log messages to Google Chrome"
     },
     "autoload": {
         "psr-4": {"Monolog\\": "src/Monolog"}
@@ -56,16 +54,13 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "2.x-dev"
+            "dev-master": "2.0.x-dev"
         }
     },
     "scripts": {
         "test": [
-            "parallel-lint . --exclude vendor",
+            "parallel-lint . --exclude vendor --exclude src/Monolog/Handler/FormattableHandlerInterface.php  --exclude src/Monolog/Handler/FormattableHandlerTrait.php --exclude src/Monolog/Handler/ProcessableHandlerInterface.php --exclude src/Monolog/Handler/ProcessableHandlerTrait.php",
             "phpunit"
         ]
-    },
-    "config": {
-        "sort-packages": true
     }
 }

vendor/monolog/monolog/src/Monolog/DateTimeImmutable.php

-<?php declare(strict_types=1);
-
-/*
- * This file is part of the Monolog package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Monolog;
-
-use DateTimeZone;
-
-/**
- * Overrides default json encoding of date time objects
- *
- * @author Menno Holtkamp
- * @author Jordi Boggiano <j.boggiano@seld.be>
- */
-class DateTimeImmutable extends \DateTimeImmutable implements \JsonSerializable
-{
-    /**
-     * @var bool
-     */
-    private $useMicroseconds;
-
-    public function __construct(bool $useMicroseconds, ?DateTimeZone $timezone = null)
-    {
-        $this->useMicroseconds = $useMicroseconds;
-
-        parent::__construct('now', $timezone);
-    }
-
-    public function jsonSerialize(): string
-    {
-        if ($this->useMicroseconds) {
-            return $this->format('Y-m-d\TH:i:s.uP');
-        }
-
-        return $this->format('Y-m-d\TH:i:sP');
-    }
-
-    public function __toString(): string
-    {
-        return $this->jsonSerialize();
-    }
-}

vendor/monolog/monolog/src/Monolog/Formatter/ChromePHPFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -23,7 +23,7 @@ class ChromePHPFormatter implements FormatterInterface
     /**
      * Translates Monolog log levels to Wildfire levels.
      */
-    private $logLevels = [
+    private $logLevels = array(
         Logger::DEBUG     => 'log',
         Logger::INFO      => 'info',
         Logger::NOTICE    => 'info',
@@ -32,7 +32,7 @@ class ChromePHPFormatter implements FormatterInterface
         Logger::CRITICAL  => 'error',
         Logger::ALERT     => 'error',
         Logger::EMERGENCY => 'error',
-    ];
+    );
 
     /**
      * {@inheritdoc}
@@ -46,7 +46,7 @@ class ChromePHPFormatter implements FormatterInterface
             unset($record['extra']['file'], $record['extra']['line']);
         }
 
-        $message = ['message' => $record['message']];
+        $message = array('message' => $record['message']);
         if ($record['context']) {
             $message['context'] = $record['context'];
         }
@@ -57,20 +57,17 @@ class ChromePHPFormatter implements FormatterInterface
             $message = reset($message);
         }
 
-        return [
+        return array(
             $record['channel'],
             $message,
             $backtrace,
             $this->logLevels[$record['level']],
-        ];
+        );
     }
 
-    /**
-     * {@inheritdoc}
-     */
     public function formatBatch(array $records)
     {
-        $formatted = [];
+        $formatted = array();
 
         foreach ($records as $record) {
             $formatted[] = $this->format($record);

vendor/monolog/monolog/src/Monolog/Formatter/ElasticaFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -34,7 +34,7 @@ class ElasticaFormatter extends NormalizerFormatter
      * @param string $index Elastic Search index name
      * @param string $type  Elastic Search document type
      */
-    public function __construct(string $index, string $type)
+    public function __construct($index, $type)
     {
         // elasticsearch requires a ISO 8601 format date with optional millisecond precision.
         parent::__construct('Y-m-d\TH:i:s.uP');
@@ -53,22 +53,31 @@ class ElasticaFormatter extends NormalizerFormatter
         return $this->getDocument($record);
     }
 
-    public function getIndex(): string
+    /**
+     * Getter index
+     * @return string
+     */
+    public function getIndex()
     {
         return $this->index;
     }
 
-    public function getType(): string
+    /**
+     * Getter type
+     * @return string
+     */
+    public function getType()
     {
         return $this->type;
     }
 
     /**
      * Convert a log message into an Elastica Document
-     * @param  array    $record
+     *
+     * @param  array    $record Log message
      * @return Document
      */
-    protected function getDocument(array $record): Document
+    protected function getDocument($record)
     {
         $document = new Document();
         $document->setData($record);

vendor/monolog/monolog/src/Monolog/Formatter/ElasticsearchFormatter.php

-<?php declare(strict_types=1);
-
-/*
- * This file is part of the Monolog package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Monolog\Formatter;
-
-use DateTime;
-
-/**
- * Format a log message into an Elasticsearch record
- *
- * @author Avtandil Kikabidze <akalongman@gmail.com>
- */
-class ElasticsearchFormatter extends NormalizerFormatter
-{
-    /**
-     * @var string Elasticsearch index name
-     */
-    protected $index;
-
-    /**
-     * @var string Elasticsearch record type
-     */
-    protected $type;
-
-    /**
-     * @param string $index Elasticsearch index name
-     * @param string $type  Elasticsearch record type
-     */
-    public function __construct(string $index, string $type)
-    {
-        // Elasticsearch requires an ISO 8601 format date with optional millisecond precision.
-        parent::__construct(DateTime::ISO8601);
-
-        $this->index = $index;
-        $this->type = $type;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function format(array $record)
-    {
-        $record = parent::format($record);
-
-        return $this->getDocument($record);
-    }
-
-    /**
-     * Getter index
-     *
-     * @return string
-     */
-    public function getIndex(): string
-    {
-        return $this->index;
-    }
-
-    /**
-     * Getter type
-     *
-     * @return string
-     */
-    public function getType(): string
-    {
-        return $this->type;
-    }
-
-    /**
-     * Convert a log message into an Elasticsearch record
-     *
-     * @param  array $record Log message
-     * @return array
-     */
-    protected function getDocument(array $record): array
-    {
-        $record['_index'] = $this->index;
-        $record['_type'] = $this->type;
-
-        return $record;
-    }
-}

vendor/monolog/monolog/src/Monolog/Formatter/FlowdockFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -28,7 +28,11 @@ class FlowdockFormatter implements FormatterInterface
      */
     private $sourceEmail;
 
-    public function __construct(string $source, string $sourceEmail)
+    /**
+     * @param string $source
+     * @param string $sourceEmail
+     */
+    public function __construct($source, $sourceEmail)
     {
         $this->source = $source;
         $this->sourceEmail = $sourceEmail;
@@ -37,13 +41,13 @@ class FlowdockFormatter implements FormatterInterface
     /**
      * {@inheritdoc}
      */
-    public function format(array $record): array
+    public function format(array $record)
     {
-        $tags = [
+        $tags = array(
             '#logs',
             '#' . strtolower($record['level_name']),
             '#' . $record['channel'],
-        ];
+        );
 
         foreach ($record['extra'] as $value) {
             $tags[] = '#' . $value;
@@ -56,14 +60,14 @@ class FlowdockFormatter implements FormatterInterface
             $this->getShortMessage($record['message'])
         );
 
-        $record['flowdock'] = [
+        $record['flowdock'] = array(
             'source' => $this->source,
             'from_address' => $this->sourceEmail,
             'subject' => $subject,
             'content' => $record['message'],
             'tags' => $tags,
             'project' => $this->source,
-        ];
+        );
 
         return $record;
     }
@@ -71,9 +75,9 @@ class FlowdockFormatter implements FormatterInterface
     /**
      * {@inheritdoc}
      */
-    public function formatBatch(array $records): array
+    public function formatBatch(array $records)
     {
-        $formatted = [];
+        $formatted = array();
 
         foreach ($records as $record) {
             $formatted[] = $this->format($record);
@@ -82,7 +86,12 @@ class FlowdockFormatter implements FormatterInterface
         return $formatted;
     }
 
-    public function getShortMessage(string $message): string
+    /**
+     * @param string $message
+     *
+     * @return string
+     */
+    public function getShortMessage($message)
     {
         static $hasMbString;
 

vendor/monolog/monolog/src/Monolog/Formatter/FluentdFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -41,42 +41,42 @@ class FluentdFormatter implements FormatterInterface
      */
     protected $levelTag = false;
 
-    public function __construct(bool $levelTag = false)
+    public function __construct($levelTag = false)
     {
         if (!function_exists('json_encode')) {
             throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s FluentdUnixFormatter');
         }
 
-        $this->levelTag = $levelTag;
+        $this->levelTag = (bool) $levelTag;
     }
 
-    public function isUsingLevelsInTag(): bool
+    public function isUsingLevelsInTag()
     {
         return $this->levelTag;
     }
 
-    public function format(array $record): string
+    public function format(array $record)
     {
         $tag = $record['channel'];
         if ($this->levelTag) {
             $tag .= '.' . strtolower($record['level_name']);
         }
 
-        $message = [
+        $message = array(
             'message' => $record['message'],
             'context' => $record['context'],
             'extra' => $record['extra'],
-        ];
+        );
 
         if (!$this->levelTag) {
             $message['level'] = $record['level'];
             $message['level_name'] = $record['level_name'];
         }
 
-        return Utils::jsonEncode([$tag, $record['datetime']->getTimestamp(), $message]);
+        return Utils::jsonEncode(array($tag, $record['datetime']->getTimestamp(), $message));
     }
 
-    public function formatBatch(array $records): string
+    public function formatBatch(array $records)
     {
         $message = '';
         foreach ($records as $record) {

vendor/monolog/monolog/src/Monolog/Formatter/FormatterInterface.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.

vendor/monolog/monolog/src/Monolog/Formatter/GelfMessageFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -13,17 +13,16 @@ namespace Monolog\Formatter;
 
 use Monolog\Logger;
 use Gelf\Message;
-use Monolog\Utils;
 
 /**
  * Serializes a log message to GELF
- * @see http://docs.graylog.org/en/latest/pages/gelf.html
+ * @see http://www.graylog2.org/about/gelf
  *
  * @author Matt Lehner <mlehner@gmail.com>
  */
 class GelfMessageFormatter extends NormalizerFormatter
 {
-    protected const DEFAULT_MAX_LENGTH = 32766;
+    const DEFAULT_MAX_LENGTH = 32766;
 
     /**
      * @var string the name of the system for the Gelf log message
@@ -48,7 +47,7 @@ class GelfMessageFormatter extends NormalizerFormatter
     /**
      * Translates Monolog log levels to Graylog2 log priorities.
      */
-    private $logLevels = [
+    private $logLevels = array(
         Logger::DEBUG     => 7,
         Logger::INFO      => 6,
         Logger::NOTICE    => 5,
@@ -57,15 +56,15 @@ class GelfMessageFormatter extends NormalizerFormatter
         Logger::CRITICAL  => 2,
         Logger::ALERT     => 1,
         Logger::EMERGENCY => 0,
-    ];
+    );
 
-    public function __construct(?string $systemName = null, ?string $extraPrefix = null, string $contextPrefix = 'ctxt_', ?int $maxLength = null)
+    public function __construct($systemName = null, $extraPrefix = null, $contextPrefix = 'ctxt_', $maxLength = null)
     {
         parent::__construct('U.u');
 
-        $this->systemName = (is_null($systemName) || $systemName === '') ? gethostname() : $systemName;
+        $this->systemName = $systemName ?: gethostname();
 
-        $this->extraPrefix = is_null($extraPrefix) ? '' : $extraPrefix;
+        $this->extraPrefix = $extraPrefix;
         $this->contextPrefix = $contextPrefix;
         $this->maxLength = is_null($maxLength) ? self::DEFAULT_MAX_LENGTH : $maxLength;
     }
@@ -73,14 +72,9 @@ class GelfMessageFormatter extends NormalizerFormatter
     /**
      * {@inheritdoc}
      */
-    public function format(array $record): Message
+    public function format(array $record)
     {
-        if (isset($record['context'])) {
-            $record['context'] = parent::format($record['context']);
-        }
-        if (isset($record['extra'])) {
-            $record['extra'] = parent::format($record['extra']);
-        }
+        $record = parent::format($record);
 
         if (!isset($record['datetime'], $record['message'], $record['level'])) {
             throw new \InvalidArgumentException('The record should at least contain datetime, message and level keys, '.var_export($record, true).' given');
@@ -93,11 +87,11 @@ class GelfMessageFormatter extends NormalizerFormatter
             ->setHost($this->systemName)
             ->setLevel($this->logLevels[$record['level']]);
 
-        // message length + system name length + 200 for padding / metadata
+        // message length + system name length + 200 for padding / metadata 
         $len = 200 + strlen((string) $record['message']) + strlen($this->systemName);
 
         if ($len > $this->maxLength) {
-            $message->setShortMessage(Utils::substr($record['message'], 0, $this->maxLength));
+            $message->setShortMessage(substr($record['message'], 0, $this->maxLength));
         }
 
         if (isset($record['channel'])) {
@@ -116,9 +110,8 @@ class GelfMessageFormatter extends NormalizerFormatter
             $val = is_scalar($val) || null === $val ? $val : $this->toJson($val);
             $len = strlen($this->extraPrefix . $key . $val);
             if ($len > $this->maxLength) {
-                $message->setAdditional($this->extraPrefix . $key, Utils::substr($val, 0, $this->maxLength));
-
-                continue;
+                $message->setAdditional($this->extraPrefix . $key, substr($val, 0, $this->maxLength));
+                break;
             }
             $message->setAdditional($this->extraPrefix . $key, $val);
         }
@@ -127,9 +120,8 @@ class GelfMessageFormatter extends NormalizerFormatter
             $val = is_scalar($val) || null === $val ? $val : $this->toJson($val);
             $len = strlen($this->contextPrefix . $key . $val);
             if ($len > $this->maxLength) {
-                $message->setAdditional($this->contextPrefix . $key, Utils::substr($val, 0, $this->maxLength));
-
-                continue;
+                $message->setAdditional($this->contextPrefix . $key, substr($val, 0, $this->maxLength));
+                break;
             }
             $message->setAdditional($this->contextPrefix . $key, $val);
         }

vendor/monolog/monolog/src/Monolog/Formatter/HtmlFormatter.php

-<?php declare(strict_types=1);
-
+<?php
 /*
  * This file is part of the Monolog package.
  *
@@ -26,7 +25,7 @@ class HtmlFormatter extends NormalizerFormatter
     /**
      * Translates Monolog log levels to html color priorities.
      */
-    protected $logLevels = [
+    protected $logLevels = array(
         Logger::DEBUG     => '#cccccc',
         Logger::INFO      => '#468847',
         Logger::NOTICE    => '#3a87ad',
@@ -35,12 +34,12 @@ class HtmlFormatter extends NormalizerFormatter
         Logger::CRITICAL  => '#FF7708',
         Logger::ALERT     => '#C12A19',
         Logger::EMERGENCY => '#000000',
-    ];
+    );
 
     /**
-     * @param string|null $dateFormat The format of the timestamp: one supported by DateTime::format
+     * @param string $dateFormat The format of the timestamp: one supported by DateTime::format
      */
-    public function __construct(?string $dateFormat = null)
+    public function __construct($dateFormat = null)
     {
         parent::__construct($dateFormat);
     }
@@ -48,11 +47,12 @@ class HtmlFormatter extends NormalizerFormatter
     /**
      * Creates an HTML table row
      *
-     * @param string $th       Row header content
-     * @param string $td       Row standard cell content
-     * @param bool   $escapeTd false if td content must not be html escaped
+     * @param  string $th       Row header content
+     * @param  string $td       Row standard cell content
+     * @param  bool   $escapeTd false if td content must not be html escaped
+     * @return string
      */
-    protected function addRow(string $th, string $td = ' ', bool $escapeTd = true): string
+    protected function addRow($th, $td = ' ', $escapeTd = true)
     {
         $th = htmlspecialchars($th, ENT_NOQUOTES, 'UTF-8');
         if ($escapeTd) {
@@ -69,7 +69,7 @@ class HtmlFormatter extends NormalizerFormatter
      * @param  int    $level Error level
      * @return string
      */
-    protected function addTitle(string $title, int $level): string
+    protected function addTitle($title, $level)
     {
         $title = htmlspecialchars($title, ENT_NOQUOTES, 'UTF-8');
 
@@ -79,21 +79,21 @@ class HtmlFormatter extends NormalizerFormatter
     /**
      * Formats a log record.
      *
-     * @param  array  $record A record to format
-     * @return string The formatted record
+     * @param  array $record A record to format
+     * @return mixed The formatted record
      */
-    public function format(array $record): string
+    public function format(array $record)
     {
         $output = $this->addTitle($record['level_name'], $record['level']);
         $output .= '<table cellspacing="1" width="100%" class="monolog-output">';
 
         $output .= $this->addRow('Message', (string) $record['message']);
-        $output .= $this->addRow('Time', $this->formatDate($record['datetime']));
+        $output .= $this->addRow('Time', $record['datetime']->format($this->dateFormat));
         $output .= $this->addRow('Channel', $record['channel']);
         if ($record['context']) {
             $embeddedTable = '<table cellspacing="1" width="100%">';
             foreach ($record['context'] as $key => $value) {
-                $embeddedTable .= $this->addRow((string)$key, $this->convertToString($value));
+                $embeddedTable .= $this->addRow($key, $this->convertToString($value));
             }
             $embeddedTable .= '</table>';
             $output .= $this->addRow('Context', $embeddedTable, false);
@@ -101,7 +101,7 @@ class HtmlFormatter extends NormalizerFormatter
         if ($record['extra']) {
             $embeddedTable = '<table cellspacing="1" width="100%">';
             foreach ($record['extra'] as $key => $value) {
-                $embeddedTable .= $this->addRow((string)$key, $this->convertToString($value));
+                $embeddedTable .= $this->addRow($key, $this->convertToString($value));
             }
             $embeddedTable .= '</table>';
             $output .= $this->addRow('Extra', $embeddedTable, false);
@@ -113,10 +113,10 @@ class HtmlFormatter extends NormalizerFormatter
     /**
      * Formats a set of log records.
      *
-     * @param  array  $records A set of records to format
-     * @return string The formatted set of records
+     * @param  array $records A set of records to format
+     * @return mixed The formatted set of records
      */
-    public function formatBatch(array $records): string
+    public function formatBatch(array $records)
     {
         $message = '';
         foreach ($records as $record) {
@@ -126,14 +126,17 @@ class HtmlFormatter extends NormalizerFormatter
         return $message;
     }
 
-    protected function convertToString($data): string
+    protected function convertToString($data)
     {
         if (null === $data || is_scalar($data)) {
             return (string) $data;
         }
 
         $data = $this->normalize($data);
+        if (version_compare(PHP_VERSION, '5.4.0', '>=')) {
+            return Utils::jsonEncode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE, true);
+        }
 
-        return Utils::jsonEncode($data, JSON_PRETTY_PRINT | Utils::DEFAULT_JSON_FLAGS, true);
+        return str_replace('\\/', '/', Utils::jsonEncode($data, null, true));
     }
 }

vendor/monolog/monolog/src/Monolog/Formatter/JsonFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,6 +11,7 @@
 
 namespace Monolog\Formatter;
 
+use Exception;
 use Monolog\Utils;
 use Throwable;
 
@@ -23,8 +24,8 @@ use Throwable;
  */
 class JsonFormatter extends NormalizerFormatter
 {
-    public const BATCH_MODE_JSON = 1;
-    public const BATCH_MODE_NEWLINES = 2;
+    const BATCH_MODE_JSON = 1;
+    const BATCH_MODE_NEWLINES = 2;
 
     protected $batchMode;
     protected $appendNewline;
@@ -34,7 +35,11 @@ class JsonFormatter extends NormalizerFormatter
      */
     protected $includeStacktraces = false;
 
-    public function __construct(int $batchMode = self::BATCH_MODE_JSON, bool $appendNewline = true)
+    /**
+     * @param int $batchMode
+     * @param bool $appendNewline
+     */
+    public function __construct($batchMode = self::BATCH_MODE_JSON, $appendNewline = true)
     {
         $this->batchMode = $batchMode;
         $this->appendNewline = $appendNewline;
@@ -46,42 +51,36 @@ class JsonFormatter extends NormalizerFormatter
      * formatted as a JSON-encoded array. However, for
      * compatibility with some API endpoints, alternative styles
      * are available.
+     *
+     * @return int
      */
-    public function getBatchMode(): int
+    public function getBatchMode()
     {
         return $this->batchMode;
     }
 
     /**
      * True if newlines are appended to every formatted record
+     *
+     * @return bool
      */
-    public function isAppendingNewlines(): bool
+    public function isAppendingNewlines()
     {
         return $this->appendNewline;
     }
 
     /**
      * {@inheritdoc}
-     *
-     * @suppress PhanTypeComparisonToArray
      */
-    public function format(array $record): string
+    public function format(array $record)
     {
-        $normalized = $this->normalize($record);
-        if (isset($normalized['context']) && $normalized['context'] === []) {
-            $normalized['context'] = new \stdClass;
-        }
-        if (isset($normalized['extra']) && $normalized['extra'] === []) {
-            $normalized['extra'] = new \stdClass;
-        }
-
-        return $this->toJson($normalized, true) . ($this->appendNewline ? "\n" : '');
+        return $this->toJson($this->normalize($record), true) . ($this->appendNewline ? "\n" : '');
     }
 
     /**
      * {@inheritdoc}
      */
-    public function formatBatch(array $records): string
+    public function formatBatch(array $records)
     {
         switch ($this->batchMode) {
             case static::BATCH_MODE_NEWLINES:
@@ -93,15 +92,21 @@ class JsonFormatter extends NormalizerFormatter
         }
     }
 
-    public function includeStacktraces(bool $include = true)
+    /**
+     * @param bool $include
+     */
+    public function includeStacktraces($include = true)
     {
         $this->includeStacktraces = $include;
     }
 
     /**
      * Return a JSON-encoded array of records.
+     *
+     * @param  array  $records
+     * @return string
      */
-    protected function formatBatchJson(array $records): string
+    protected function formatBatchJson(array $records)
     {
         return $this->toJson($this->normalize($records), true);
     }
@@ -109,8 +114,11 @@ class JsonFormatter extends NormalizerFormatter
     /**
      * Use new lines to separate records instead of a
      * JSON-encoded array.
+     *
+     * @param  array  $records
+     * @return string
      */
-    protected function formatBatchNewlines(array $records): string
+    protected function formatBatchNewlines(array $records)
     {
         $instance = $this;
 
@@ -131,30 +139,30 @@ class JsonFormatter extends NormalizerFormatter
      *
      * @return mixed
      */
-    protected function normalize($data, int $depth = 0)
+    protected function normalize($data, $depth = 0)
     {
-        if ($depth > $this->maxNormalizeDepth) {
-            return 'Over '.$this->maxNormalizeDepth.' levels deep, aborting normalization';
+        if ($depth > 9) {
+            return 'Over 9 levels deep, aborting normalization';
         }
 
         if (is_array($data)) {
-            $normalized = [];
+            $normalized = array();
 
             $count = 1;
             foreach ($data as $key => $value) {
-                if ($count++ > $this->maxNormalizeItemCount) {
-                    $normalized['...'] = 'Over '.$this->maxNormalizeItemCount.' items ('.count($data).' total), aborting normalization';
+                if ($count++ > 1000) {
+                    $normalized['...'] = 'Over 1000 items ('.count($data).' total), aborting normalization';
                     break;
                 }
 
-                $normalized[$key] = $this->normalize($value, $depth + 1);
+                $normalized[$key] = $this->normalize($value, $depth+1);
             }
 
             return $normalized;
         }
 
-        if ($data instanceof Throwable) {
-            return $this->normalizeException($data, $depth);
+        if ($data instanceof Exception || $data instanceof Throwable) {
+            return $this->normalizeException($data);
         }
 
         if (is_resource($data)) {
@@ -167,12 +175,36 @@ class JsonFormatter extends NormalizerFormatter
     /**
      * Normalizes given exception with or without its own stack trace based on
      * `includeStacktraces` property.
+     *
+     * @param Exception|Throwable $e
+     *
+     * @return array
      */
-    protected function normalizeException(Throwable $e, int $depth = 0): array
+    protected function normalizeException($e)
     {
-        $data = parent::normalizeException($e, $depth);
-        if (!$this->includeStacktraces) {
-            unset($data['trace']);
+        // TODO 2.0 only check for Throwable
+        if (!$e instanceof Exception && !$e instanceof Throwable) {
+            throw new \InvalidArgumentException('Exception/Throwable expected, got '.gettype($e).' / '.Utils::getClass($e));
+        }
+
+        $data = array(
+            'class' => Utils::getClass($e),
+            'message' => $e->getMessage(),
+            'code' => (int) $e->getCode(),
+            'file' => $e->getFile().':'.$e->getLine(),
+        );
+
+        if ($this->includeStacktraces) {
+            $trace = $e->getTrace();
+            foreach ($trace as $frame) {
+                if (isset($frame['file'])) {
+                    $data['trace'][] = $frame['file'].':'.$frame['line'];
+                }
+            }
+        }
+
+        if ($previous = $e->getPrevious()) {
+            $data['previous'] = $this->normalizeException($previous);
         }
 
         return $data;

vendor/monolog/monolog/src/Monolog/Formatter/LineFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -23,7 +23,7 @@ use Monolog\Utils;
  */
 class LineFormatter extends NormalizerFormatter
 {
-    public const SIMPLE_FORMAT = "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n";
+    const SIMPLE_FORMAT = "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n";
 
     protected $format;
     protected $allowInlineLineBreaks;
@@ -31,20 +31,20 @@ class LineFormatter extends NormalizerFormatter
     protected $includeStacktraces;
 
     /**
-     * @param string|null $format                     The format of the message
-     * @param string|null $dateFormat                 The format of the timestamp: one supported by DateTime::format
-     * @param bool        $allowInlineLineBreaks      Whether to allow inline line breaks in log entries
-     * @param bool        $ignoreEmptyContextAndExtra
+     * @param string $format                     The format of the message
+     * @param string $dateFormat                 The format of the timestamp: one supported by DateTime::format
+     * @param bool   $allowInlineLineBreaks      Whether to allow inline line breaks in log entries
+     * @param bool   $ignoreEmptyContextAndExtra
      */
-    public function __construct(?string $format = null, ?string $dateFormat = null, bool $allowInlineLineBreaks = false, bool $ignoreEmptyContextAndExtra = false)
+    public function __construct($format = null, $dateFormat = null, $allowInlineLineBreaks = false, $ignoreEmptyContextAndExtra = false)
     {
-        $this->format = $format === null ? static::SIMPLE_FORMAT : $format;
+        $this->format = $format ?: static::SIMPLE_FORMAT;
         $this->allowInlineLineBreaks = $allowInlineLineBreaks;
         $this->ignoreEmptyContextAndExtra = $ignoreEmptyContextAndExtra;
         parent::__construct($dateFormat);
     }
 
-    public function includeStacktraces(bool $include = true)
+    public function includeStacktraces($include = true)
     {
         $this->includeStacktraces = $include;
         if ($this->includeStacktraces) {
@@ -52,12 +52,12 @@ class LineFormatter extends NormalizerFormatter
         }
     }
 
-    public function allowInlineLineBreaks(bool $allow = true)
+    public function allowInlineLineBreaks($allow = true)
     {
         $this->allowInlineLineBreaks = $allow;
     }
 
-    public function ignoreEmptyContextAndExtra(bool $ignore = true)
+    public function ignoreEmptyContextAndExtra($ignore = true)
     {
         $this->ignoreEmptyContextAndExtra = $ignore;
     }
@@ -65,7 +65,7 @@ class LineFormatter extends NormalizerFormatter
     /**
      * {@inheritdoc}
      */
-    public function format(array $record): string
+    public function format(array $record)
     {
         $vars = parent::format($record);
 
@@ -78,6 +78,7 @@ class LineFormatter extends NormalizerFormatter
             }
         }
 
+
         foreach ($vars['context'] as $var => $val) {
             if (false !== strpos($output, '%context.'.$var.'%')) {
                 $output = str_replace('%context.'.$var.'%', $this->stringify($val), $output);
@@ -111,7 +112,7 @@ class LineFormatter extends NormalizerFormatter
         return $output;
     }
 
-    public function formatBatch(array $records): string
+    public function formatBatch(array $records)
     {
         $message = '';
         foreach ($records as $record) {
@@ -121,28 +122,34 @@ class LineFormatter extends NormalizerFormatter
         return $message;
     }
 
-    public function stringify($value): string
+    public function stringify($value)
     {
         return $this->replaceNewlines($this->convertToString($value));
     }
 
-    /**
-     * @suppress PhanParamSignatureMismatch
-     */
-    protected function normalizeException(\Throwable $e, int $depth = 0): string
+    protected function normalizeException($e)
     {
-        $str = $this->formatException($e);
+        // TODO 2.0 only check for Throwable
+        if (!$e instanceof \Exception && !$e instanceof \Throwable) {
+            throw new \InvalidArgumentException('Exception/Throwable expected, got '.gettype($e).' / '.Utils::getClass($e));
+        }
 
+        $previousText = '';
         if ($previous = $e->getPrevious()) {
             do {
-                $str .= "\n[previous exception] " . $this->formatException($previous);
+                $previousText .= ', '.Utils::getClass($previous).'(code: '.$previous->getCode().'): '.$previous->getMessage().' at '.$previous->getFile().':'.$previous->getLine();
             } while ($previous = $previous->getPrevious());
         }
 
+        $str = '[object] ('.Utils::getClass($e).'(code: '.$e->getCode().'): '.$e->getMessage().' at '.$e->getFile().':'.$e->getLine().$previousText.')';
+        if ($this->includeStacktraces) {
+            $str .= "\n[stacktrace]\n".$e->getTraceAsString()."\n";
+        }
+
         return $str;
     }
 
-    protected function convertToString($data): string
+    protected function convertToString($data)
     {
         if (null === $data || is_bool($data)) {
             return var_export($data, true);
@@ -152,10 +159,14 @@ class LineFormatter extends NormalizerFormatter
             return (string) $data;
         }
 
-        return $this->toJson($data, true);
+        if (version_compare(PHP_VERSION, '5.4.0', '>=')) {
+            return $this->toJson($data, true);
+        }
+
+        return str_replace('\\/', '/', $this->toJson($data, true));
     }
 
-    protected function replaceNewlines(string $str): string
+    protected function replaceNewlines($str)
     {
         if ($this->allowInlineLineBreaks) {
             if (0 === strpos($str, '{')) {
@@ -165,31 +176,6 @@ class LineFormatter extends NormalizerFormatter
             return $str;
         }
 
-        return str_replace(["\r\n", "\r", "\n"], ' ', $str);
-    }
-
-    private function formatException(\Throwable $e): string
-    {
-        $str = '[object] (' . Utils::getClass($e) . '(code: ' . $e->getCode();
-        if ($e instanceof \SoapFault) {
-            if (isset($e->faultcode)) {
-                $str .= ' faultcode: ' . $e->faultcode;
-            }
-
-            if (isset($e->faultactor)) {
-                $str .= ' faultactor: ' . $e->faultactor;
-            }
-
-            if (isset($e->detail) && (is_string($e->detail) || is_object($e->detail) || is_array($e->detail))) {
-                $str .= ' detail: ' . (is_string($e->detail) ? $e->detail : reset($e->detail));
-            }
-        }
-        $str .= '): ' . $e->getMessage() . ' at ' . $e->getFile() . ':' . $e->getLine() . ')';
-
-        if ($this->includeStacktraces) {
-            $str .= "\n[stacktrace]\n" . $e->getTraceAsString() . "\n";
-        }
-
-        return $str;
+        return str_replace(array("\r\n", "\r", "\n"), ' ', $str);
     }
 }

vendor/monolog/monolog/src/Monolog/Formatter/LogglyFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -21,8 +21,10 @@ class LogglyFormatter extends JsonFormatter
     /**
      * Overrides the default batch mode to new lines for compatibility with the
      * Loggly bulk API.
+     *
+     * @param int $batchMode
      */
-    public function __construct(int $batchMode = self::BATCH_MODE_NEWLINES, bool $appendNewline = false)
+    public function __construct($batchMode = self::BATCH_MODE_NEWLINES, $appendNewline = false)
     {
         parent::__construct($batchMode, $appendNewline);
     }
@@ -33,11 +35,11 @@ class LogglyFormatter extends JsonFormatter
      * @see https://www.loggly.com/docs/automated-parsing/#json
      * @see \Monolog\Formatter\JsonFormatter::format()
      */
-    public function format(array $record): string
+    public function format(array $record)
     {
-        if (isset($record["datetime"]) && ($record["datetime"] instanceof \DateTimeInterface)) {
+        if (isset($record["datetime"]) && ($record["datetime"] instanceof \DateTime)) {
             $record["timestamp"] = $record["datetime"]->format("Y-m-d\TH:i:s.uO");
-            unset($record["datetime"]);
+            // TODO 2.0 unset the 'datetime' parameter, retained for BC
         }
 
         return parent::format($record);

vendor/monolog/monolog/src/Monolog/Formatter/LogmaticFormatter.php

-<?php declare(strict_types=1);
-
-/*
- * This file is part of the Monolog package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Monolog\Formatter;
-
-/**
- * Encodes message information into JSON in a format compatible with Logmatic.
- *
- * @author Julien Breux <julien.breux@gmail.com>
- */
-class LogmaticFormatter extends JsonFormatter
-{
-    protected const MARKERS = ["sourcecode", "php"];
-
-    /**
-     * @var string
-     */
-    protected $hostname = '';
-
-    /**
-     * @var string
-     */
-    protected $appname = '';
-
-    public function setHostname(string $hostname): self
-    {
-        $this->hostname = $hostname;
-
-        return $this;
-    }
-
-    public function setAppname(string $appname): self
-    {
-        $this->appname = $appname;
-
-        return $this;
-    }
-
-    /**
-     * Appends the 'hostname' and 'appname' parameter for indexing by Logmatic.
-     *
-     * @see http://doc.logmatic.io/docs/basics-to-send-data
-     * @see \Monolog\Formatter\JsonFormatter::format()
-     */
-    public function format(array $record): string
-    {
-        if (!empty($this->hostname)) {
-            $record["hostname"] = $this->hostname;
-        }
-        if (!empty($this->appname)) {
-            $record["appname"] = $this->appname;
-        }
-
-        $record["@marker"] = static::MARKERS;
-
-        return parent::format($record);
-    }
-}

vendor/monolog/monolog/src/Monolog/Formatter/LogstashFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -14,13 +14,16 @@ namespace Monolog\Formatter;
 /**
  * Serializes a log message to Logstash Event Format
  *
- * @see https://www.elastic.co/products/logstash
- * @see https://github.com/elastic/logstash/blob/master/logstash-core/src/main/java/org/logstash/Event.java
+ * @see http://logstash.net/
+ * @see https://github.com/logstash/logstash/blob/master/lib/logstash/event.rb
  *
  * @author Tim Mower <timothy.mower@gmail.com>
  */
 class LogstashFormatter extends NormalizerFormatter
 {
+    const V0 = 0;
+    const V1 = 1;
+
     /**
      * @var string the name of the system for the Logstash log message, used to fill the @source field
      */
@@ -32,47 +35,108 @@ class LogstashFormatter extends NormalizerFormatter
     protected $applicationName;
 
     /**
-     * @var string the key for 'extra' fields from the Monolog record
+     * @var string a prefix for 'extra' fields from the Monolog record (optional)
      */
-    protected $extraKey;
+    protected $extraPrefix;
 
     /**
-     * @var string the key for 'context' fields from the Monolog record
+     * @var string a prefix for 'context' fields from the Monolog record (optional)
      */
-    protected $contextKey;
+    protected $contextPrefix;
 
     /**
-     * @param string      $applicationName The application that sends the data, used as the "type" field of logstash
-     * @param string|null $systemName      The system/machine name, used as the "source" field of logstash, defaults to the hostname of the machine
-     * @param string      $extraKey        The key for extra keys inside logstash "fields", defaults to extra
-     * @param string      $contextKey      The key for context keys inside logstash "fields", defaults to context
+     * @var int logstash format version to use
      */
-    public function __construct(string $applicationName, ?string $systemName = null, string $extraKey = 'extra', string $contextKey = 'context')
+    protected $version;
+
+    /**
+     * @param string $applicationName the application that sends the data, used as the "type" field of logstash
+     * @param string $systemName      the system/machine name, used as the "source" field of logstash, defaults to the hostname of the machine
+     * @param string $extraPrefix     prefix for extra keys inside logstash "fields"
+     * @param string $contextPrefix   prefix for context keys inside logstash "fields", defaults to ctxt_
+     * @param int    $version         the logstash format version to use, defaults to 0
+     */
+    public function __construct($applicationName, $systemName = null, $extraPrefix = null, $contextPrefix = 'ctxt_', $version = self::V0)
     {
         // logstash requires a ISO 8601 format date with optional millisecond precision.
         parent::__construct('Y-m-d\TH:i:s.uP');
 
-        $this->systemName = $systemName === null ? gethostname() : $systemName;
+        $this->systemName = $systemName ?: gethostname();
         $this->applicationName = $applicationName;
-        $this->extraKey = $extraKey;
-        $this->contextKey = $contextKey;
+        $this->extraPrefix = $extraPrefix;
+        $this->contextPrefix = $contextPrefix;
+        $this->version = $version;
     }
 
     /**
      * {@inheritdoc}
      */
-    public function format(array $record): string
+    public function format(array $record)
     {
         $record = parent::format($record);
 
+        if ($this->version === self::V1) {
+            $message = $this->formatV1($record);
+        } else {
+            $message = $this->formatV0($record);
+        }
+
+        return $this->toJson($message) . "\n";
+    }
+
+    protected function formatV0(array $record)
+    {
         if (empty($record['datetime'])) {
             $record['datetime'] = gmdate('c');
         }
-        $message = [
+        $message = array(
+            '@timestamp' => $record['datetime'],
+            '@source' => $this->systemName,
+            '@fields' => array(),
+        );
+        if (isset($record['message'])) {
+            $message['@message'] = $record['message'];
+        }
+        if (isset($record['channel'])) {
+            $message['@tags'] = array($record['channel']);
+            $message['@fields']['channel'] = $record['channel'];
+        }
+        if (isset($record['level'])) {
+            $message['@fields']['level'] = $record['level'];
+        }
+        if ($this->applicationName) {
+            $message['@type'] = $this->applicationName;
+        }
+        if (isset($record['extra']['server'])) {
+            $message['@source_host'] = $record['extra']['server'];
+        }
+        if (isset($record['extra']['url'])) {
+            $message['@source_path'] = $record['extra']['url'];
+        }
+        if (!empty($record['extra'])) {
+            foreach ($record['extra'] as $key => $val) {
+                $message['@fields'][$this->extraPrefix . $key] = $val;
+            }
+        }
+        if (!empty($record['context'])) {
+            foreach ($record['context'] as $key => $val) {
+                $message['@fields'][$this->contextPrefix . $key] = $val;
+            }
+        }
+
+        return $message;
+    }
+
+    protected function formatV1(array $record)
+    {
+        if (empty($record['datetime'])) {
+            $record['datetime'] = gmdate('c');
+        }
+        $message = array(
             '@timestamp' => $record['datetime'],
             '@version' => 1,
             'host' => $this->systemName,
-        ];
+        );
         if (isset($record['message'])) {
             $message['message'] = $record['message'];
         }
@@ -83,19 +147,20 @@ class LogstashFormatter extends NormalizerFormatter
         if (isset($record['level_name'])) {
             $message['level'] = $record['level_name'];
         }
-        if (isset($record['level'])) {
-            $message['monolog_level'] = $record['level'];
-        }
         if ($this->applicationName) {
             $message['type'] = $this->applicationName;
         }
         if (!empty($record['extra'])) {
-            $message[$this->extraKey] = $record['extra'];
+            foreach ($record['extra'] as $key => $val) {
+                $message[$this->extraPrefix . $key] = $val;
+            }
         }
         if (!empty($record['context'])) {
-            $message[$this->contextKey] = $record['context'];
+            foreach ($record['context'] as $key => $val) {
+                $message[$this->contextPrefix . $key] = $val;
+            }
         }
 
-        return $this->toJson($message) . "\n";
+        return $message;
     }
 }

vendor/monolog/monolog/src/Monolog/Formatter/MongoDBFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,7 +11,6 @@
 
 namespace Monolog\Formatter;
 
-use MongoDB\BSON\UTCDateTime;
 use Monolog\Utils;
 
 /**
@@ -23,24 +22,21 @@ class MongoDBFormatter implements FormatterInterface
 {
     private $exceptionTraceAsString;
     private $maxNestingLevel;
-    private $isLegacyMongoExt;
 
     /**
      * @param int  $maxNestingLevel        0 means infinite nesting, the $record itself is level 1, $record['context'] is 2
      * @param bool $exceptionTraceAsString set to false to log exception traces as a sub documents instead of strings
      */
-    public function __construct(int $maxNestingLevel = 3, bool $exceptionTraceAsString = true)
+    public function __construct($maxNestingLevel = 3, $exceptionTraceAsString = true)
     {
         $this->maxNestingLevel = max($maxNestingLevel, 0);
-        $this->exceptionTraceAsString = $exceptionTraceAsString;
-
-        $this->isLegacyMongoExt = version_compare(phpversion('mongodb'), '1.1.9', '<=');
+        $this->exceptionTraceAsString = (bool) $exceptionTraceAsString;
     }
 
     /**
      * {@inheritDoc}
      */
-    public function format(array $record): array
+    public function format(array $record)
     {
         return $this->formatArray($record);
     }
@@ -48,7 +44,7 @@ class MongoDBFormatter implements FormatterInterface
     /**
      * {@inheritDoc}
      */
-    public function formatBatch(array $records): array
+    public function formatBatch(array $records)
     {
         foreach ($records as $key => $record) {
             $records[$key] = $this->format($record);
@@ -57,16 +53,13 @@ class MongoDBFormatter implements FormatterInterface
         return $records;
     }
 
-    /**
-     * @return array|string Array except when max nesting level is reached then a string "[...]"
-     */
-    protected function formatArray(array $record, int $nestingLevel = 0)
+    protected function formatArray(array $record, $nestingLevel = 0)
     {
         if ($this->maxNestingLevel == 0 || $nestingLevel <= $this->maxNestingLevel) {
             foreach ($record as $name => $value) {
-                if ($value instanceof \DateTimeInterface) {
+                if ($value instanceof \DateTime) {
                     $record[$name] = $this->formatDate($value, $nestingLevel + 1);
-                } elseif ($value instanceof \Throwable) {
+                } elseif ($value instanceof \Exception) {
                     $record[$name] = $this->formatException($value, $nestingLevel + 1);
                 } elseif (is_array($value)) {
                     $record[$name] = $this->formatArray($value, $nestingLevel + 1);
@@ -81,7 +74,7 @@ class MongoDBFormatter implements FormatterInterface
         return $record;
     }
 
-    protected function formatObject($value, int $nestingLevel)
+    protected function formatObject($value, $nestingLevel)
     {
         $objectVars = get_object_vars($value);
         $objectVars['class'] = Utils::getClass($value);
@@ -89,14 +82,14 @@ class MongoDBFormatter implements FormatterInterface
         return $this->formatArray($objectVars, $nestingLevel);
     }
 
-    protected function formatException(\Throwable $exception, int $nestingLevel)
+    protected function formatException(\Exception $exception, $nestingLevel)
     {
-        $formattedException = [
+        $formattedException = array(
             'class' => Utils::getClass($exception),
             'message' => $exception->getMessage(),
             'code' => (int) $exception->getCode(),
             'file' => $exception->getFile() . ':' . $exception->getLine(),
-        ];
+        );
 
         if ($this->exceptionTraceAsString === true) {
             $formattedException['trace'] = $exception->getTraceAsString();
@@ -107,35 +100,8 @@ class MongoDBFormatter implements FormatterInterface
         return $this->formatArray($formattedException, $nestingLevel);
     }
 
-    protected function formatDate(\DateTimeInterface $value, int $nestingLevel): UTCDateTime
-    {
-        if ($this->isLegacyMongoExt) {
-            return $this->legacyGetMongoDbDateTime($value);
-        }
-
-        return $this->getMongoDbDateTime($value);
-    }
-
-    private function getMongoDbDateTime(\DateTimeInterface $value): UTCDateTime
+    protected function formatDate(\DateTime $value, $nestingLevel)
     {
-        return new UTCDateTime((int) (string) floor($value->format('U.u') * 1000));
-    }
-
-    /**
-     * This is needed to support MongoDB Driver v1.19 and below
-     *
-     * See https://github.com/mongodb/mongo-php-driver/issues/426
-     *
-     * It can probably be removed in 2.1 or later once MongoDB's 1.2 is released and widely adopted
-     */
-    private function legacyGetMongoDbDateTime(\DateTimeInterface $value): UTCDateTime
-    {
-        $milliseconds = floor($value->format('U.u') * 1000);
-
-        $milliseconds = (PHP_INT_SIZE == 8) //64-bit OS?
-            ? (int) $milliseconds
-            : (string) $milliseconds;
-
-        return new UTCDateTime($milliseconds);
+        return new \MongoDate($value->getTimestamp());
     }
 }

vendor/monolog/monolog/src/Monolog/Formatter/NormalizerFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,9 +11,8 @@
 
 namespace Monolog\Formatter;
 
-use Monolog\DateTimeImmutable;
+use Exception;
 use Monolog\Utils;
-use Throwable;
 
 /**
  * Normalizes incoming records to remove objects/resources so it's easier to dump to various targets
@@ -22,20 +21,16 @@ use Throwable;
  */
 class NormalizerFormatter implements FormatterInterface
 {
-    public const SIMPLE_DATE = "Y-m-d\TH:i:sP";
+    const SIMPLE_DATE = "Y-m-d H:i:s";
 
     protected $dateFormat;
-    protected $maxNormalizeDepth = 9;
-    protected $maxNormalizeItemCount = 1000;
-
-    private $jsonEncodeOptions = Utils::DEFAULT_JSON_FLAGS;
 
     /**
-     * @param string|null $dateFormat The format of the timestamp: one supported by DateTime::format
+     * @param string $dateFormat The format of the timestamp: one supported by DateTime::format
      */
-    public function __construct(?string $dateFormat = null)
+    public function __construct($dateFormat = null)
     {
-        $this->dateFormat = null === $dateFormat ? static::SIMPLE_DATE : $dateFormat;
+        $this->dateFormat = $dateFormat ?: static::SIMPLE_DATE;
         if (!function_exists('json_encode')) {
             throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s NormalizerFormatter');
         }
@@ -61,58 +56,10 @@ class NormalizerFormatter implements FormatterInterface
         return $records;
     }
 
-    /**
-     * The maximum number of normalization levels to go through
-     */
-    public function getMaxNormalizeDepth(): int
-    {
-        return $this->maxNormalizeDepth;
-    }
-
-    public function setMaxNormalizeDepth(int $maxNormalizeDepth): self
-    {
-        $this->maxNormalizeDepth = $maxNormalizeDepth;
-
-        return $this;
-    }
-
-    /**
-     * The maximum number of items to normalize per level
-     */
-    public function getMaxNormalizeItemCount(): int
-    {
-        return $this->maxNormalizeItemCount;
-    }
-
-    public function setMaxNormalizeItemCount(int $maxNormalizeItemCount): self
-    {
-        $this->maxNormalizeItemCount = $maxNormalizeItemCount;
-
-        return $this;
-    }
-
-    /**
-     * Enables `json_encode` pretty print.
-     */
-    public function setJsonPrettyPrint(bool $enable): self
-    {
-        if ($enable) {
-            $this->jsonEncodeOptions |= JSON_PRETTY_PRINT;
-        } else {
-            $this->jsonEncodeOptions ^= JSON_PRETTY_PRINT;
-        }
-
-        return $this;
-    }
-
-    /**
-     * @param  mixed                      $data
-     * @return int|bool|string|null|array
-     */
-    protected function normalize($data, int $depth = 0)
+    protected function normalize($data, $depth = 0)
     {
-        if ($depth > $this->maxNormalizeDepth) {
-            return 'Over ' . $this->maxNormalizeDepth . ' levels deep, aborting normalization';
+        if ($depth > 9) {
+            return 'Over 9 levels deep, aborting normalization';
         }
 
         if (null === $data || is_scalar($data)) {
@@ -129,69 +76,62 @@ class NormalizerFormatter implements FormatterInterface
         }
 
         if (is_array($data)) {
-            $normalized = [];
+            $normalized = array();
 
             $count = 1;
             foreach ($data as $key => $value) {
-                if ($count++ > $this->maxNormalizeItemCount) {
-                    $normalized['...'] = 'Over ' . $this->maxNormalizeItemCount . ' items ('.count($data).' total), aborting normalization';
+                if ($count++ > 1000) {
+                    $normalized['...'] = 'Over 1000 items ('.count($data).' total), aborting normalization';
                     break;
                 }
 
-                $normalized[$key] = $this->normalize($value, $depth + 1);
+                $normalized[$key] = $this->normalize($value, $depth+1);
             }
 
             return $normalized;
         }
 
-        if ($data instanceof \DateTimeInterface) {
-            return $this->formatDate($data);
+        if ($data instanceof \DateTime) {
+            return $data->format($this->dateFormat);
         }
 
         if (is_object($data)) {
-            if ($data instanceof Throwable) {
-                return $this->normalizeException($data, $depth);
+            // TODO 2.0 only check for Throwable
+            if ($data instanceof Exception || (PHP_VERSION_ID > 70000 && $data instanceof \Throwable)) {
+                return $this->normalizeException($data);
             }
 
-            if ($data instanceof \JsonSerializable) {
-                $value = $data->jsonSerialize();
-            } elseif (method_exists($data, '__toString')) {
+            // non-serializable objects that implement __toString stringified
+            if (method_exists($data, '__toString') && !$data instanceof \JsonSerializable) {
                 $value = $data->__toString();
             } else {
-                // the rest is normalized by json encoding and decoding it
-                $encoded = $this->toJson($data, true);
-                if ($encoded === false) {
-                    $value = 'JSON_ERROR';
-                } else {
-                    $value = json_decode($encoded, true);
-                }
+                // the rest is json-serialized in some way
+                $value = $this->toJson($data, true);
             }
 
-            return [Utils::getClass($data) => $value];
+            return sprintf("[object] (%s: %s)", Utils::getClass($data), $value);
         }
 
         if (is_resource($data)) {
-            return sprintf('[resource(%s)]', get_resource_type($data));
+            return sprintf('[resource] (%s)', get_resource_type($data));
         }
 
         return '[unknown('.gettype($data).')]';
     }
 
-    /**
-     * @return array
-     */
-    protected function normalizeException(Throwable $e, int $depth = 0)
+    protected function normalizeException($e)
     {
-        if ($e instanceof \JsonSerializable) {
-            return (array) $e->jsonSerialize();
+        // TODO 2.0 only check for Throwable
+        if (!$e instanceof Exception && !$e instanceof \Throwable) {
+            throw new \InvalidArgumentException('Exception/Throwable expected, got '.gettype($e).' / '.Utils::getClass($e));
         }
 
-        $data = [
+        $data = array(
             'class' => Utils::getClass($e),
             'message' => $e->getMessage(),
             'code' => (int) $e->getCode(),
             'file' => $e->getFile().':'.$e->getLine(),
-        ];
+        );
 
         if ($e instanceof \SoapFault) {
             if (isset($e->faultcode)) {
@@ -215,7 +155,7 @@ class NormalizerFormatter implements FormatterInterface
         }
 
         if ($previous = $e->getPrevious()) {
-            $data['previous'] = $this->normalizeException($previous, $depth + 1);
+            $data['previous'] = $this->normalizeException($previous);
         }
 
         return $data;
@@ -225,32 +165,12 @@ class NormalizerFormatter implements FormatterInterface
      * Return the JSON representation of a value
      *
      * @param  mixed             $data
+     * @param  bool              $ignoreErrors
      * @throws \RuntimeException if encoding fails and errors are not ignored
-     * @return string if encoding fails and ignoreErrors is true 'null' is returned
+     * @return string
      */
-    protected function toJson($data, bool $ignoreErrors = false): string
-    {
-        return Utils::jsonEncode($data, $this->jsonEncodeOptions, $ignoreErrors);
-    }
-
-    protected function formatDate(\DateTimeInterface $date)
-    {
-        // in case the date format isn't custom then we defer to the custom DateTimeImmutable
-        // formatting logic, which will pick the right format based on whether useMicroseconds is on
-        if ($this->dateFormat === self::SIMPLE_DATE && $date instanceof DateTimeImmutable) {
-            return (string) $date;
-        }
-
-        return $date->format($this->dateFormat);
-    }
-
-    protected function addJsonEncodeOption($option)
-    {
-        $this->jsonEncodeOptions |= $option;
-    }
-
-    protected function removeJsonEncodeOption($option)
+    protected function toJson($data, $ignoreErrors = false)
     {
-        $this->jsonEncodeOptions ^= $option;
+        return Utils::jsonEncode($data, null, $ignoreErrors);
     }
 }

vendor/monolog/monolog/src/Monolog/Formatter/ScalarFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -22,7 +22,7 @@ class ScalarFormatter extends NormalizerFormatter
     /**
      * {@inheritdoc}
      */
-    public function format(array $record): array
+    public function format(array $record)
     {
         foreach ($record as $key => $value) {
             $record[$key] = $this->normalizeValue($value);

vendor/monolog/monolog/src/Monolog/Formatter/WildfireFormatter.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -22,10 +22,12 @@ use Monolog\Logger;
  */
 class WildfireFormatter extends NormalizerFormatter
 {
+    const TABLE = 'table';
+
     /**
      * Translates Monolog log levels to Wildfire levels.
      */
-    private $logLevels = [
+    private $logLevels = array(
         Logger::DEBUG     => 'LOG',
         Logger::INFO      => 'INFO',
         Logger::NOTICE    => 'INFO',
@@ -34,12 +36,12 @@ class WildfireFormatter extends NormalizerFormatter
         Logger::CRITICAL  => 'ERROR',
         Logger::ALERT     => 'ERROR',
         Logger::EMERGENCY => 'ERROR',
-    ];
+    );
 
     /**
      * {@inheritdoc}
      */
-    public function format(array $record): string
+    public function format(array $record)
     {
         // Retrieve the line and file if set and remove them from the formatted extra
         $file = $line = '';
@@ -53,7 +55,7 @@ class WildfireFormatter extends NormalizerFormatter
         }
 
         $record = $this->normalize($record);
-        $message = ['message' => $record['message']];
+        $message = array('message' => $record['message']);
         $handleError = false;
         if ($record['context']) {
             $message['context'] = $record['context'];
@@ -67,49 +69,42 @@ class WildfireFormatter extends NormalizerFormatter
             $message = reset($message);
         }
 
-        if (isset($record['context']['table'])) {
+        if (isset($record['context'][self::TABLE])) {
             $type  = 'TABLE';
             $label = $record['channel'] .': '. $record['message'];
-            $message = $record['context']['table'];
+            $message = $record['context'][self::TABLE];
         } else {
             $type  = $this->logLevels[$record['level']];
             $label = $record['channel'];
         }
 
         // Create JSON object describing the appearance of the message in the console
-        $json = $this->toJson([
-            [
+        $json = $this->toJson(array(
+            array(
                 'Type'  => $type,
                 'File'  => $file,
                 'Line'  => $line,
                 'Label' => $label,
-            ],
+            ),
             $message,
-        ], $handleError);
+        ), $handleError);
 
         // The message itself is a serialization of the above JSON object + it's length
         return sprintf(
-            '%d|%s|',
+            '%s|%s|',
             strlen($json),
             $json
         );
     }
 
-    /**
-     * {@inheritdoc}
-     */
     public function formatBatch(array $records)
     {
         throw new \BadMethodCallException('Batch formatting does not make sense for the WildfireFormatter');
     }
 
-    /**
-     * {@inheritdoc}
-     * @suppress PhanTypeMismatchReturn
-     */
-    protected function normalize($data, int $depth = 0)
+    protected function normalize($data, $depth = 0)
     {
-        if (is_object($data) && !$data instanceof \DateTimeInterface) {
+        if (is_object($data) && !$data instanceof \DateTime) {
             return $data;
         }
 

vendor/monolog/monolog/src/Monolog/Handler/AbstractHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,24 +11,32 @@
 
 namespace Monolog\Handler;
 
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LineFormatter;
 use Monolog\Logger;
 use Monolog\ResettableInterface;
 
 /**
- * Base Handler class providing basic level/bubble support
+ * Base Handler class providing the Handler structure
  *
  * @author Jordi Boggiano <j.boggiano@seld.be>
  */
-abstract class AbstractHandler extends Handler implements ResettableInterface
+abstract class AbstractHandler implements HandlerInterface, ResettableInterface
 {
     protected $level = Logger::DEBUG;
     protected $bubble = true;
 
     /**
-     * @param int|string $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
+     * @var FormatterInterface
      */
-    public function __construct($level = Logger::DEBUG, bool $bubble = true)
+    protected $formatter;
+    protected $processors = array();
+
+    /**
+     * @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
+     */
+    public function __construct($level = Logger::DEBUG, $bubble = true)
     {
         $this->setLevel($level);
         $this->bubble = $bubble;
@@ -37,18 +45,84 @@ abstract class AbstractHandler extends Handler implements ResettableInterface
     /**
      * {@inheritdoc}
      */
-    public function isHandling(array $record): bool
+    public function isHandling(array $record)
     {
         return $record['level'] >= $this->level;
     }
 
     /**
+     * {@inheritdoc}
+     */
+    public function handleBatch(array $records)
+    {
+        foreach ($records as $record) {
+            $this->handle($record);
+        }
+    }
+
+    /**
+     * Closes the handler.
+     *
+     * This will be called automatically when the object is destroyed
+     */
+    public function close()
+    {
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function pushProcessor($callback)
+    {
+        if (!is_callable($callback)) {
+            throw new \InvalidArgumentException('Processors must be valid callables (callback or object with an __invoke method), '.var_export($callback, true).' given');
+        }
+        array_unshift($this->processors, $callback);
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function popProcessor()
+    {
+        if (!$this->processors) {
+            throw new \LogicException('You tried to pop from an empty processor stack.');
+        }
+
+        return array_shift($this->processors);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setFormatter(FormatterInterface $formatter)
+    {
+        $this->formatter = $formatter;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getFormatter()
+    {
+        if (!$this->formatter) {
+            $this->formatter = $this->getDefaultFormatter();
+        }
+
+        return $this->formatter;
+    }
+
+    /**
      * Sets minimum logging level at which this handler will be triggered.
      *
      * @param  int|string $level Level or level name
      * @return self
      */
-    public function setLevel($level): self
+    public function setLevel($level)
     {
         $this->level = Logger::toMonologLevel($level);
 
@@ -60,7 +134,7 @@ abstract class AbstractHandler extends Handler implements ResettableInterface
      *
      * @return int
      */
-    public function getLevel(): int
+    public function getLevel()
     {
         return $this->level;
     }
@@ -72,7 +146,7 @@ abstract class AbstractHandler extends Handler implements ResettableInterface
      *                      false means that bubbling is not permitted.
      * @return self
      */
-    public function setBubble(bool $bubble): self
+    public function setBubble($bubble)
     {
         $this->bubble = $bubble;
 
@@ -85,12 +159,38 @@ abstract class AbstractHandler extends Handler implements ResettableInterface
      * @return bool true means that this handler allows bubbling.
      *              false means that bubbling is not permitted.
      */
-    public function getBubble(): bool
+    public function getBubble()
     {
         return $this->bubble;
     }
 
+    public function __destruct()
+    {
+        try {
+            $this->close();
+        } catch (\Exception $e) {
+            // do nothing
+        } catch (\Throwable $e) {
+            // do nothing
+        }
+    }
+
     public function reset()
     {
+        foreach ($this->processors as $processor) {
+            if ($processor instanceof ResettableInterface) {
+                $processor->reset();
+            }
+        }
+    }
+
+    /**
+     * Gets the default formatter.
+     *
+     * @return FormatterInterface
+     */
+    protected function getDefaultFormatter()
+    {
+        return new LineFormatter();
     }
 }

vendor/monolog/monolog/src/Monolog/Handler/AbstractProcessingHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,31 +11,28 @@
 
 namespace Monolog\Handler;
 
+use Monolog\ResettableInterface;
+
 /**
- * Base Handler class providing the Handler structure, including processors and formatters
+ * Base Handler class providing the Handler structure
  *
  * Classes extending it should (in most cases) only implement write($record)
  *
  * @author Jordi Boggiano <j.boggiano@seld.be>
  * @author Christophe Coevoet <stof@notk.org>
  */
-abstract class AbstractProcessingHandler extends AbstractHandler implements ProcessableHandlerInterface, FormattableHandlerInterface
+abstract class AbstractProcessingHandler extends AbstractHandler
 {
-    use ProcessableHandlerTrait;
-    use FormattableHandlerTrait;
-
     /**
      * {@inheritdoc}
      */
-    public function handle(array $record): bool
+    public function handle(array $record)
     {
         if (!$this->isHandling($record)) {
             return false;
         }
 
-        if ($this->processors) {
-            $record = $this->processRecord($record);
-        }
+        $record = $this->processRecord($record);
 
         $record['formatted'] = $this->getFormatter()->format($record);
 
@@ -46,13 +43,26 @@ abstract class AbstractProcessingHandler extends AbstractHandler implements Proc
 
     /**
      * Writes the record down to the log of the implementing handler
+     *
+     * @param  array $record
+     * @return void
      */
-    abstract protected function write(array $record): void;
+    abstract protected function write(array $record);
 
-    public function reset()
+    /**
+     * Processes a record.
+     *
+     * @param  array $record
+     * @return array
+     */
+    protected function processRecord(array $record)
     {
-        parent::reset();
+        if ($this->processors) {
+            foreach ($this->processors as $processor) {
+                $record = call_user_func($processor, $record);
+            }
+        }
 
-        $this->resetProcessors();
+        return $record;
     }
 }

vendor/monolog/monolog/src/Monolog/Handler/AbstractSyslogHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -12,7 +12,6 @@
 namespace Monolog\Handler;
 
 use Monolog\Logger;
-use Monolog\Formatter\FormatterInterface;
 use Monolog\Formatter\LineFormatter;
 
 /**
@@ -25,7 +24,7 @@ abstract class AbstractSyslogHandler extends AbstractProcessingHandler
     /**
      * Translates Monolog log levels to syslog log priorities.
      */
-    protected $logLevels = [
+    protected $logLevels = array(
         Logger::DEBUG     => LOG_DEBUG,
         Logger::INFO      => LOG_INFO,
         Logger::NOTICE    => LOG_NOTICE,
@@ -34,12 +33,12 @@ abstract class AbstractSyslogHandler extends AbstractProcessingHandler
         Logger::CRITICAL  => LOG_CRIT,
         Logger::ALERT     => LOG_ALERT,
         Logger::EMERGENCY => LOG_EMERG,
-    ];
+    );
 
     /**
      * List of valid log facility names.
      */
-    protected $facilities = [
+    protected $facilities = array(
         'auth'     => LOG_AUTH,
         'authpriv' => LOG_AUTHPRIV,
         'cron'     => LOG_CRON,
@@ -51,14 +50,14 @@ abstract class AbstractSyslogHandler extends AbstractProcessingHandler
         'syslog'   => LOG_SYSLOG,
         'user'     => LOG_USER,
         'uucp'     => LOG_UUCP,
-    ];
+    );
 
     /**
-     * @param string|int $facility Either one of the names of the keys in $this->facilities, or a LOG_* facility constant
-     * @param string|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
+     * @param mixed $facility
+     * @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
      */
-    public function __construct($facility = LOG_USER, $level = Logger::DEBUG, bool $bubble = true)
+    public function __construct($facility = LOG_USER, $level = Logger::DEBUG, $bubble = true)
     {
         parent::__construct($level, $bubble);
 
@@ -83,7 +82,7 @@ abstract class AbstractSyslogHandler extends AbstractProcessingHandler
         }
 
         // convert textual description of facility to syslog constant
-        if (is_string($facility) && array_key_exists(strtolower($facility), $this->facilities)) {
+        if (array_key_exists(strtolower($facility), $this->facilities)) {
             $facility = $this->facilities[strtolower($facility)];
         } elseif (!in_array($facility, array_values($this->facilities), true)) {
             throw new \UnexpectedValueException('Unknown facility value "'.$facility.'" given');
@@ -95,7 +94,7 @@ abstract class AbstractSyslogHandler extends AbstractProcessingHandler
     /**
      * {@inheritdoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new LineFormatter('%channel%.%level_name%: %message% %context% %extra%');
     }

vendor/monolog/monolog/src/Monolog/Handler/AmqpHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -12,7 +12,6 @@
 namespace Monolog\Handler;
 
 use Monolog\Logger;
-use Monolog\Formatter\FormatterInterface;
 use Monolog\Formatter\JsonFormatter;
 use PhpAmqpLib\Message\AMQPMessage;
 use PhpAmqpLib\Channel\AMQPChannel;
@@ -32,18 +31,18 @@ class AmqpHandler extends AbstractProcessingHandler
 
     /**
      * @param AMQPExchange|AMQPChannel $exchange     AMQPExchange (php AMQP ext) or PHP AMQP lib channel, ready for use
-     * @param string|null              $exchangeName Optional exchange name, for AMQPChannel (PhpAmqpLib) only
-     * @param string|int               $level        The minimum logging level at which this handler will be triggered
+     * @param string                   $exchangeName
+     * @param int                      $level
      * @param bool                     $bubble       Whether the messages that are handled can bubble up the stack or not
      */
-    public function __construct($exchange, ?string $exchangeName = null, $level = Logger::DEBUG, bool $bubble = true)
+    public function __construct($exchange, $exchangeName = 'log', $level = Logger::DEBUG, $bubble = true)
     {
-        if ($exchange instanceof AMQPChannel) {
-            $this->exchangeName = (string) $exchangeName;
-        } elseif (!$exchange instanceof AMQPExchange) {
+        if ($exchange instanceof AMQPExchange) {
+            $exchange->setName($exchangeName);
+        } elseif ($exchange instanceof AMQPChannel) {
+            $this->exchangeName = $exchangeName;
+        } else {
             throw new \InvalidArgumentException('PhpAmqpLib\Channel\AMQPChannel or AMQPExchange instance required');
-        } elseif ($exchangeName) {
-            @trigger_error('The $exchangeName parameter can only be passed when using PhpAmqpLib, if using an AMQPExchange instance configure it beforehand', E_USER_DEPRECATED);
         }
         $this->exchange = $exchange;
 
@@ -53,7 +52,7 @@ class AmqpHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
         $data = $record["formatted"];
         $routingKey = $this->getRoutingKey($record);
@@ -63,10 +62,10 @@ class AmqpHandler extends AbstractProcessingHandler
                 $data,
                 $routingKey,
                 0,
-                [
+                array(
                     'delivery_mode' => 2,
                     'content_type' => 'application/json',
-                ]
+                )
             );
         } else {
             $this->exchange->basic_publish(
@@ -80,7 +79,7 @@ class AmqpHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    public function handleBatch(array $records): void
+    public function handleBatch(array $records)
     {
         if ($this->exchange instanceof AMQPExchange) {
             parent::handleBatch($records);
@@ -108,29 +107,41 @@ class AmqpHandler extends AbstractProcessingHandler
 
     /**
      * Gets the routing key for the AMQP exchange
+     *
+     * @param  array  $record
+     * @return string
      */
-    protected function getRoutingKey(array $record): string
+    protected function getRoutingKey(array $record)
     {
-        $routingKey = sprintf('%s.%s', $record['level_name'], $record['channel']);
+        $routingKey = sprintf(
+            '%s.%s',
+            // TODO 2.0 remove substr call
+            substr($record['level_name'], 0, 4),
+            $record['channel']
+        );
 
         return strtolower($routingKey);
     }
 
-    private function createAmqpMessage(string $data): AMQPMessage
+    /**
+     * @param  string      $data
+     * @return AMQPMessage
+     */
+    private function createAmqpMessage($data)
     {
         return new AMQPMessage(
-            $data,
-            [
+            (string) $data,
+            array(
                 'delivery_mode' => 2,
                 'content_type' => 'application/json',
-            ]
+            )
         );
     }
 
     /**
      * {@inheritDoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new JsonFormatter(JsonFormatter::BATCH_MODE_JSON, false);
     }

vendor/monolog/monolog/src/Monolog/Handler/BrowserConsoleHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -12,8 +12,6 @@
 namespace Monolog\Handler;
 
 use Monolog\Formatter\LineFormatter;
-use Monolog\Formatter\FormatterInterface;
-use Monolog\Utils;
 
 /**
  * Handler sending logs to browser's javascript console with no browser extension required
@@ -23,7 +21,7 @@ use Monolog\Utils;
 class BrowserConsoleHandler extends AbstractProcessingHandler
 {
     protected static $initialized = false;
-    protected static $records = [];
+    protected static $records = array();
 
     /**
      * {@inheritDoc}
@@ -34,7 +32,7 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
      *
      *     You can do [[blue text]]{color: blue} or [[green background]]{background-color: green; color: white}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new LineFormatter('[[%channel%]]{macro: autolabel} [[%level_name%]]{font-weight: bold} %message%');
     }
@@ -42,7 +40,7 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
         // Accumulate records
         static::$records[] = $record;
@@ -58,7 +56,7 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
      * Convert records to javascript console commands and send it to the browser.
      * This method is automatically called on PHP shutdown if output is HTML or Javascript.
      */
-    public static function send(): void
+    public static function send()
     {
         $format = static::getResponseFormat();
         if ($format === 'unknown') {
@@ -75,40 +73,40 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
         }
     }
 
-    public function close(): void
+    public function close()
     {
         self::resetStatic();
     }
 
     public function reset()
     {
-        parent::reset();
-
         self::resetStatic();
     }
 
     /**
      * Forget all logged records
      */
-    public static function resetStatic(): void
+    public static function resetStatic()
     {
-        static::$records = [];
+        static::$records = array();
     }
 
     /**
      * Wrapper for register_shutdown_function to allow overriding
      */
-    protected function registerShutdownFunction(): void
+    protected function registerShutdownFunction()
     {
         if (PHP_SAPI !== 'cli') {
-            register_shutdown_function(['Monolog\Handler\BrowserConsoleHandler', 'send']);
+            register_shutdown_function(array('Monolog\Handler\BrowserConsoleHandler', 'send'));
         }
     }
 
     /**
      * Wrapper for echo to allow overriding
+     *
+     * @param string $str
      */
-    protected static function writeOutput(string $str): void
+    protected static function writeOutput($str)
     {
         echo $str;
     }
@@ -122,7 +120,7 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
      *
      * @return string One of 'js', 'html' or 'unknown'
      */
-    protected static function getResponseFormat(): string
+    protected static function getResponseFormat()
     {
         // Check content type
         foreach (headers_list() as $header) {
@@ -142,9 +140,9 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
         return 'html';
     }
 
-    private static function generateScript(): string
+    private static function generateScript()
     {
-        $script = [];
+        $script = array();
         foreach (static::$records as $record) {
             $context = static::dump('Context', $record['context']);
             $extra = static::dump('Extra', $record['extra']);
@@ -152,12 +150,11 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
             if (empty($context) && empty($extra)) {
                 $script[] = static::call_array('log', static::handleStyles($record['formatted']));
             } else {
-                $script = array_merge(
-                    $script,
-                    [static::call_array('groupCollapsed', static::handleStyles($record['formatted']))],
+                $script = array_merge($script,
+                    array(static::call_array('groupCollapsed', static::handleStyles($record['formatted']))),
                     $context,
                     $extra,
-                    [static::call('groupEnd')]
+                    array(static::call('groupEnd'))
                 );
             }
         }
@@ -165,9 +162,9 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
         return "(function (c) {if (c && c.groupCollapsed) {\n" . implode("\n", $script) . "\n}})(console);";
     }
 
-    private static function handleStyles(string $formatted): array
+    private static function handleStyles($formatted)
     {
-        $args = [];
+        $args = array();
         $format = '%c' . $formatted;
         preg_match_all('/\[\[(.*?)\]\]\{([^}]*)\}/s', $format, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
 
@@ -176,7 +173,7 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
             $args[] = static::quote(static::handleCustomStyles($match[2][0], $match[1][0]));
 
             $pos = $match[0][1];
-            $format = Utils::substr($format, 0, $pos) . '%c' . $match[1][0] . '%c' . Utils::substr($format, $pos + strlen($match[0][0]));
+            $format = substr($format, 0, $pos) . '%c' . $match[1][0] . '%c' . substr($format, $pos + strlen($match[0][0]));
         }
 
         $args[] = static::quote('font-weight: normal');
@@ -185,12 +182,12 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
         return array_reverse($args);
     }
 
-    private static function handleCustomStyles(string $style, string $string): string
+    private static function handleCustomStyles($style, $string)
     {
-        static $colors = ['blue', 'green', 'red', 'magenta', 'orange', 'black', 'grey'];
-        static $labels = [];
+        static $colors = array('blue', 'green', 'red', 'magenta', 'orange', 'black', 'grey');
+        static $labels = array();
 
-        return preg_replace_callback('/macro\s*:(.*?)(?:;|$)/', function (array $m) use ($string, &$colors, &$labels) {
+        return preg_replace_callback('/macro\s*:(.*?)(?:;|$)/', function ($m) use ($string, &$colors, &$labels) {
             if (trim($m[1]) === 'autolabel') {
                 // Format the string as a label with consistent auto assigned background color
                 if (!isset($labels[$string])) {
@@ -205,9 +202,9 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
         }, $style);
     }
 
-    private static function dump(string $title, array $dict): array
+    private static function dump($title, array $dict)
     {
-        $script = [];
+        $script = array();
         $dict = array_filter($dict);
         if (empty($dict)) {
             return $script;
@@ -218,25 +215,26 @@ class BrowserConsoleHandler extends AbstractProcessingHandler
             if (empty($value)) {
                 $value = static::quote('');
             }
-            $script[] = static::call('log', static::quote('%s: %o'), static::quote((string) $key), $value);
+            $script[] = static::call('log', static::quote('%s: %o'), static::quote($key), $value);
         }
 
         return $script;
     }
 
-    private static function quote(string $arg): string
+    private static function quote($arg)
     {
         return '"' . addcslashes($arg, "\"\n\\") . '"';
     }
 
-    private static function call(...$args): string
+    private static function call()
     {
+        $args = func_get_args();
         $method = array_shift($args);
 
         return static::call_array($method, $args);
     }
 
-    private static function call_array(string $method, array $args): string
+    private static function call_array($method, array $args)
     {
         return 'c.' . $method . '(' . implode(', ', $args) . ');';
     }

vendor/monolog/monolog/src/Monolog/Handler/BufferHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -23,36 +23,34 @@ use Monolog\Formatter\FormatterInterface;
  *
  * @author Christophe Coevoet <stof@notk.org>
  */
-class BufferHandler extends AbstractHandler implements ProcessableHandlerInterface, FormattableHandlerInterface
+class BufferHandler extends AbstractHandler
 {
-    use ProcessableHandlerTrait;
-
     protected $handler;
     protected $bufferSize = 0;
     protected $bufferLimit;
     protected $flushOnOverflow;
-    protected $buffer = [];
+    protected $buffer = array();
     protected $initialized = false;
 
     /**
      * @param HandlerInterface $handler         Handler.
      * @param int              $bufferLimit     How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
-     * @param string|int       $level           The minimum logging level at which this handler will be triggered
+     * @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
      * @param bool             $flushOnOverflow If true, the buffer is flushed when the max size has been reached, by default oldest entries are discarded
      */
-    public function __construct(HandlerInterface $handler, int $bufferLimit = 0, $level = Logger::DEBUG, bool $bubble = true, bool $flushOnOverflow = false)
+    public function __construct(HandlerInterface $handler, $bufferLimit = 0, $level = Logger::DEBUG, $bubble = true, $flushOnOverflow = false)
     {
         parent::__construct($level, $bubble);
         $this->handler = $handler;
-        $this->bufferLimit = $bufferLimit;
+        $this->bufferLimit = (int) $bufferLimit;
         $this->flushOnOverflow = $flushOnOverflow;
     }
 
     /**
      * {@inheritdoc}
      */
-    public function handle(array $record): bool
+    public function handle(array $record)
     {
         if ($record['level'] < $this->level) {
             return false;
@@ -60,7 +58,7 @@ class BufferHandler extends AbstractHandler implements ProcessableHandlerInterfa
 
         if (!$this->initialized) {
             // __destructor() doesn't get called on Fatal errors
-            register_shutdown_function([$this, 'close']);
+            register_shutdown_function(array($this, 'close'));
             $this->initialized = true;
         }
 
@@ -74,7 +72,9 @@ class BufferHandler extends AbstractHandler implements ProcessableHandlerInterfa
         }
 
         if ($this->processors) {
-            $record = $this->processRecord($record);
+            foreach ($this->processors as $processor) {
+                $record = call_user_func($processor, $record);
+            }
         }
 
         $this->buffer[] = $record;
@@ -83,7 +83,7 @@ class BufferHandler extends AbstractHandler implements ProcessableHandlerInterfa
         return false === $this->bubble;
     }
 
-    public function flush(): void
+    public function flush()
     {
         if ($this->bufferSize === 0) {
             return;
@@ -103,20 +103,18 @@ class BufferHandler extends AbstractHandler implements ProcessableHandlerInterfa
     /**
      * {@inheritdoc}
      */
-    public function close(): void
+    public function close()
     {
         $this->flush();
-
-        $this->handler->close();
     }
 
     /**
      * Clears the buffer without flushing any messages down to the wrapped handler.
      */
-    public function clear(): void
+    public function clear()
     {
         $this->bufferSize = 0;
-        $this->buffer = [];
+        $this->buffer = array();
     }
 
     public function reset()
@@ -125,8 +123,6 @@ class BufferHandler extends AbstractHandler implements ProcessableHandlerInterfa
 
         parent::reset();
 
-        $this->resetProcessors();
-
         if ($this->handler instanceof ResettableInterface) {
             $this->handler->reset();
         }
@@ -135,7 +131,7 @@ class BufferHandler extends AbstractHandler implements ProcessableHandlerInterfa
     /**
      * {@inheritdoc}
      */
-    public function setFormatter(FormatterInterface $formatter): HandlerInterface
+    public function setFormatter(FormatterInterface $formatter)
     {
         $this->handler->setFormatter($formatter);
 
@@ -145,7 +141,7 @@ class BufferHandler extends AbstractHandler implements ProcessableHandlerInterfa
     /**
      * {@inheritdoc}
      */
-    public function getFormatter(): FormatterInterface
+    public function getFormatter()
     {
         return $this->handler->getFormatter();
     }

vendor/monolog/monolog/src/Monolog/Handler/ChromePHPHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -12,7 +12,6 @@
 namespace Monolog\Handler;
 
 use Monolog\Formatter\ChromePHPFormatter;
-use Monolog\Formatter\FormatterInterface;
 use Monolog\Logger;
 use Monolog\Utils;
 
@@ -25,22 +24,20 @@ use Monolog\Utils;
  */
 class ChromePHPHandler extends AbstractProcessingHandler
 {
-    use WebRequestRecognizerTrait;
-
     /**
      * Version of the extension
      */
-    protected const VERSION = '4.0';
+    const VERSION = '4.0';
 
     /**
      * Header name
      */
-    protected const HEADER_NAME = 'X-ChromeLogger-Data';
+    const HEADER_NAME = 'X-ChromeLogger-Data';
 
     /**
      * Regular expression to detect supported browsers (matches any Chrome, or Firefox 43+)
      */
-    protected const USER_AGENT_REGEX = '{\b(?:Chrome/\d+(?:\.\d+)*|HeadlessChrome|Firefox/(?:4[3-9]|[5-9]\d|\d{3,})(?:\.\d)*)\b}';
+    const USER_AGENT_REGEX = '{\b(?:Chrome/\d+(?:\.\d+)*|HeadlessChrome|Firefox/(?:4[3-9]|[5-9]\d|\d{3,})(?:\.\d)*)\b}';
 
     protected static $initialized = false;
 
@@ -53,19 +50,19 @@ class ChromePHPHandler extends AbstractProcessingHandler
      */
     protected static $overflowed = false;
 
-    protected static $json = [
+    protected static $json = array(
         'version' => self::VERSION,
-        'columns' => ['label', 'log', 'backtrace', 'type'],
-        'rows' => [],
-    ];
+        'columns' => array('label', 'log', 'backtrace', 'type'),
+        'rows' => array(),
+    );
 
     protected static $sendHeaders = true;
 
     /**
-     * @param string|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
+     * @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
      */
-    public function __construct($level = Logger::DEBUG, bool $bubble = true)
+    public function __construct($level = Logger::DEBUG, $bubble = true)
     {
         parent::__construct($level, $bubble);
         if (!function_exists('json_encode')) {
@@ -76,13 +73,9 @@ class ChromePHPHandler extends AbstractProcessingHandler
     /**
      * {@inheritdoc}
      */
-    public function handleBatch(array $records): void
+    public function handleBatch(array $records)
     {
-        if (!$this->isWebRequest()) {
-            return;
-        }
-
-        $messages = [];
+        $messages = array();
 
         foreach ($records as $record) {
             if ($record['level'] < $this->level) {
@@ -101,7 +94,7 @@ class ChromePHPHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new ChromePHPFormatter();
     }
@@ -111,13 +104,10 @@ class ChromePHPHandler extends AbstractProcessingHandler
      *
      * @see sendHeader()
      * @see send()
+     * @param array $record
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
-        if (!$this->isWebRequest()) {
-            return;
-        }
-
         self::$json['rows'][] = $record['formatted'];
 
         $this->send();
@@ -128,7 +118,7 @@ class ChromePHPHandler extends AbstractProcessingHandler
      *
      * @see sendHeader()
      */
-    protected function send(): void
+    protected function send()
     {
         if (self::$overflowed || !self::$sendHeaders) {
             return;
@@ -142,7 +132,7 @@ class ChromePHPHandler extends AbstractProcessingHandler
                 return;
             }
 
-            self::$json['request_uri'] = $_SERVER['REQUEST_URI'] ?? '';
+            self::$json['request_uri'] = isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : '';
         }
 
         $json = Utils::jsonEncode(self::$json, null, true);
@@ -150,29 +140,32 @@ class ChromePHPHandler extends AbstractProcessingHandler
         if (strlen($data) > 3 * 1024) {
             self::$overflowed = true;
 
-            $record = [
+            $record = array(
                 'message' => 'Incomplete logs, chrome header size limit reached',
-                'context' => [],
+                'context' => array(),
                 'level' => Logger::WARNING,
                 'level_name' => Logger::getLevelName(Logger::WARNING),
                 'channel' => 'monolog',
-                'datetime' => new \DateTimeImmutable(),
-                'extra' => [],
-            ];
+                'datetime' => new \DateTime(),
+                'extra' => array(),
+            );
             self::$json['rows'][count(self::$json['rows']) - 1] = $this->getFormatter()->format($record);
             $json = Utils::jsonEncode(self::$json, null, true);
             $data = base64_encode(utf8_encode($json));
         }
 
         if (trim($data) !== '') {
-            $this->sendHeader(static::HEADER_NAME, $data);
+            $this->sendHeader(self::HEADER_NAME, $data);
         }
     }
 
     /**
      * Send header string to the client
+     *
+     * @param string $header
+     * @param string $content
      */
-    protected function sendHeader(string $header, string $content): void
+    protected function sendHeader($header, $content)
     {
         if (!headers_sent() && self::$sendHeaders) {
             header(sprintf('%s: %s', $header, $content));
@@ -181,13 +174,39 @@ class ChromePHPHandler extends AbstractProcessingHandler
 
     /**
      * Verifies if the headers are accepted by the current user agent
+     *
+     * @return bool
      */
-    protected function headersAccepted(): bool
+    protected function headersAccepted()
     {
         if (empty($_SERVER['HTTP_USER_AGENT'])) {
             return false;
         }
 
-        return preg_match(static::USER_AGENT_REGEX, $_SERVER['HTTP_USER_AGENT']) === 1;
+        return preg_match(self::USER_AGENT_REGEX, $_SERVER['HTTP_USER_AGENT']);
+    }
+
+    /**
+     * BC getter for the sendHeaders property that has been made static
+     */
+    public function __get($property)
+    {
+        if ('sendHeaders' !== $property) {
+            throw new \InvalidArgumentException('Undefined property '.$property);
+        }
+
+        return static::$sendHeaders;
+    }
+
+    /**
+     * BC setter for the sendHeaders property that has been made static
+     */
+    public function __set($property, $value)
+    {
+        if ('sendHeaders' !== $property) {
+            throw new \InvalidArgumentException('Undefined property '.$property);
+        }
+
+        static::$sendHeaders = $value;
     }
 }

vendor/monolog/monolog/src/Monolog/Handler/CouchDBHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,7 +11,6 @@
 
 namespace Monolog\Handler;
 
-use Monolog\Formatter\FormatterInterface;
 use Monolog\Formatter\JsonFormatter;
 use Monolog\Logger;
 
@@ -24,15 +23,15 @@ class CouchDBHandler extends AbstractProcessingHandler
 {
     private $options;
 
-    public function __construct(array $options = [], $level = Logger::DEBUG, bool $bubble = true)
+    public function __construct(array $options = array(), $level = Logger::DEBUG, $bubble = true)
     {
-        $this->options = array_merge([
+        $this->options = array_merge(array(
             'host'     => 'localhost',
             'port'     => 5984,
             'dbname'   => 'logger',
             'username' => null,
             'password' => null,
-        ], $options);
+        ), $options);
 
         parent::__construct($level, $bubble);
     }
@@ -40,7 +39,7 @@ class CouchDBHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
         $basicAuth = null;
         if ($this->options['username']) {
@@ -48,17 +47,17 @@ class CouchDBHandler extends AbstractProcessingHandler
         }
 
         $url = 'http://'.$basicAuth.$this->options['host'].':'.$this->options['port'].'/'.$this->options['dbname'];
-        $context = stream_context_create([
-            'http' => [
+        $context = stream_context_create(array(
+            'http' => array(
                 'method'        => 'POST',
                 'content'       => $record['formatted'],
                 'ignore_errors' => true,
                 'max_redirects' => 0,
                 'header'        => 'Content-type: application/json',
-            ],
-        ]);
+            ),
+        ));
 
-        if (false === @file_get_contents($url, false, $context)) {
+        if (false === @file_get_contents($url, null, $context)) {
             throw new \RuntimeException(sprintf('Could not connect to %s', $url));
         }
     }
@@ -66,7 +65,7 @@ class CouchDBHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new JsonFormatter(JsonFormatter::BATCH_MODE_JSON, false);
     }

vendor/monolog/monolog/src/Monolog/Handler/CubeHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -27,7 +27,7 @@ class CubeHandler extends AbstractProcessingHandler
     private $scheme;
     private $host;
     private $port;
-    private $acceptedSchemes = ['http', 'udp'];
+    private $acceptedSchemes = array('http', 'udp');
 
     /**
      * Create a Cube handler
@@ -36,7 +36,7 @@ class CubeHandler extends AbstractProcessingHandler
      *                                   A valid url must consist of three parts : protocol://host:port
      *                                   Only valid protocols used by Cube are http and udp
      */
-    public function __construct(string $url, $level = Logger::DEBUG, bool $bubble = true)
+    public function __construct($url, $level = Logger::DEBUG, $bubble = true)
     {
         $urlInfo = parse_url($url);
 
@@ -47,8 +47,7 @@ class CubeHandler extends AbstractProcessingHandler
         if (!in_array($urlInfo['scheme'], $this->acceptedSchemes)) {
             throw new \UnexpectedValueException(
                 'Invalid protocol (' . $urlInfo['scheme']  . ').'
-                . ' Valid options are ' . implode(', ', $this->acceptedSchemes)
-            );
+                . ' Valid options are ' . implode(', ', $this->acceptedSchemes));
         }
 
         $this->scheme = $urlInfo['scheme'];
@@ -64,7 +63,7 @@ class CubeHandler extends AbstractProcessingHandler
      * @throws \LogicException           when unable to connect to the socket
      * @throws MissingExtensionException when there is no socket extension
      */
-    protected function connectUdp(): void
+    protected function connectUdp()
     {
         if (!extension_loaded('sockets')) {
             throw new MissingExtensionException('The sockets extension is required to use udp URLs with the CubeHandler');
@@ -81,15 +80,13 @@ class CubeHandler extends AbstractProcessingHandler
     }
 
     /**
-     * Establish a connection to an http server
-     *
-     * @throws \LogicException           when unable to connect to the socket
-     * @throws MissingExtensionException when no curl extension
+     * Establish a connection to a http server
+     * @throws \LogicException when no curl extension
      */
-    protected function connectHttp(): void
+    protected function connectHttp()
     {
         if (!extension_loaded('curl')) {
-            throw new MissingExtensionException('The curl extension is required to use http URLs with the CubeHandler');
+            throw new \LogicException('The curl extension is needed to use http URLs with the CubeHandler');
         }
 
         $this->httpConnection = curl_init('http://'.$this->host.':'.$this->port.'/1.0/event/put');
@@ -105,11 +102,11 @@ class CubeHandler extends AbstractProcessingHandler
     /**
      * {@inheritdoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
         $date = $record['datetime'];
 
-        $data = ['time' => $date->format('Y-m-d\TH:i:s.uO')];
+        $data = array('time' => $date->format('Y-m-d\TH:i:s.uO'));
         unset($record['datetime']);
 
         if (isset($record['context']['type'])) {
@@ -129,7 +126,7 @@ class CubeHandler extends AbstractProcessingHandler
         }
     }
 
-    private function writeUdp(string $data): void
+    private function writeUdp($data)
     {
         if (!$this->udpConnection) {
             $this->connectUdp();
@@ -138,17 +135,17 @@ class CubeHandler extends AbstractProcessingHandler
         socket_send($this->udpConnection, $data, strlen($data), 0);
     }
 
-    private function writeHttp(string $data): void
+    private function writeHttp($data)
     {
         if (!$this->httpConnection) {
             $this->connectHttp();
         }
 
         curl_setopt($this->httpConnection, CURLOPT_POSTFIELDS, '['.$data.']');
-        curl_setopt($this->httpConnection, CURLOPT_HTTPHEADER, [
+        curl_setopt($this->httpConnection, CURLOPT_HTTPHEADER, array(
             'Content-Type: application/json',
             'Content-Length: ' . strlen('['.$data.']'),
-        ]);
+        ));
 
         Curl\Util::execute($this->httpConnection, 5, false);
     }

vendor/monolog/monolog/src/Monolog/Handler/Curl/Util.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,14 +11,9 @@
 
 namespace Monolog\Handler\Curl;
 
-/**
- * This class is marked as internal and it is not under the BC promise of the package.
- *
- * @internal
- */
-final class Util
+class Util
 {
-    private static $retriableErrorCodes = [
+    private static $retriableErrorCodes = array(
         CURLE_COULDNT_RESOLVE_HOST,
         CURLE_COULDNT_CONNECT,
         CURLE_HTTP_NOT_FOUND,
@@ -26,21 +21,18 @@ final class Util
         CURLE_OPERATION_TIMEOUTED,
         CURLE_HTTP_POST_ERROR,
         CURLE_SSL_CONNECT_ERROR,
-    ];
+    );
 
     /**
      * Executes a CURL request with optional retries and exception on failure
      *
-     * @param  resource    $ch             curl handler
-     * @param  int         $retries
-     * @param  bool        $closeAfterDone
-     * @return bool|string @see curl_exec
+     * @param  resource          $ch curl handler
+     * @throws \RuntimeException
      */
-    public static function execute($ch, int $retries = 5, bool $closeAfterDone = true)
+    public static function execute($ch, $retries = 5, $closeAfterDone = true)
     {
         while ($retries--) {
-            $curlResponse = curl_exec($ch);
-            if ($curlResponse === false) {
+            if (curl_exec($ch) === false) {
                 $curlErrno = curl_errno($ch);
 
                 if (false === in_array($curlErrno, self::$retriableErrorCodes, true) || !$retries) {
@@ -50,7 +42,7 @@ final class Util
                         curl_close($ch);
                     }
 
-                    throw new \RuntimeException(sprintf('Curl error (code %d): %s', $curlErrno, $curlError));
+                    throw new \RuntimeException(sprintf('Curl error (code %s): %s', $curlErrno, $curlError));
                 }
 
                 continue;
@@ -59,10 +51,7 @@ final class Util
             if ($closeAfterDone) {
                 curl_close($ch);
             }
-
-            return $curlResponse;
+            break;
         }
-
-        return false;
     }
 }

vendor/monolog/monolog/src/Monolog/Handler/DeduplicationHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -58,11 +58,11 @@ class DeduplicationHandler extends BufferHandler
     /**
      * @param HandlerInterface $handler            Handler.
      * @param string           $deduplicationStore The file/path where the deduplication log should be kept
-     * @param string|int       $deduplicationLevel The minimum logging level for log records to be looked at for deduplication purposes
+     * @param int              $deduplicationLevel The minimum logging level for log records to be looked at for deduplication purposes
      * @param int              $time               The period (in seconds) during which duplicate entries should be suppressed after a given log is sent through
      * @param bool             $bubble             Whether the messages that are handled can bubble up the stack or not
      */
-    public function __construct(HandlerInterface $handler, ?string $deduplicationStore = null, $deduplicationLevel = Logger::ERROR, int $time = 60, bool $bubble = true)
+    public function __construct(HandlerInterface $handler, $deduplicationStore = null, $deduplicationLevel = Logger::ERROR, $time = 60, $bubble = true)
     {
         parent::__construct($handler, 0, Logger::DEBUG, $bubble, false);
 
@@ -71,7 +71,7 @@ class DeduplicationHandler extends BufferHandler
         $this->time = $time;
     }
 
-    public function flush(): void
+    public function flush()
     {
         if ($this->bufferSize === 0) {
             return;
@@ -81,6 +81,7 @@ class DeduplicationHandler extends BufferHandler
 
         foreach ($this->buffer as $record) {
             if ($record['level'] >= $this->deduplicationLevel) {
+
                 $passthru = $passthru || !$this->isDuplicate($record);
                 if ($passthru) {
                     $this->appendRecord($record);
@@ -100,7 +101,7 @@ class DeduplicationHandler extends BufferHandler
         }
     }
 
-    private function isDuplicate(array $record): bool
+    private function isDuplicate(array $record)
     {
         if (!file_exists($this->deduplicationStore)) {
             return false;
@@ -130,26 +131,21 @@ class DeduplicationHandler extends BufferHandler
         return false;
     }
 
-    private function collectLogs(): void
+    private function collectLogs()
     {
         if (!file_exists($this->deduplicationStore)) {
-            return;
+            return false;
         }
 
         $handle = fopen($this->deduplicationStore, 'rw+');
-
-        if (!$handle) {
-            throw new \RuntimeException('Failed to open file for reading and writing: ' . $this->deduplicationStore);
-        }
-
         flock($handle, LOCK_EX);
-        $validLogs = [];
+        $validLogs = array();
 
         $timestampValidity = time() - $this->time;
 
         while (!feof($handle)) {
             $log = fgets($handle);
-            if ($log && substr($log, 0, 10) >= $timestampValidity) {
+            if (substr($log, 0, 10) >= $timestampValidity) {
                 $validLogs[] = $log;
             }
         }
@@ -166,7 +162,7 @@ class DeduplicationHandler extends BufferHandler
         $this->gc = false;
     }
 
-    private function appendRecord(array $record): void
+    private function appendRecord(array $record)
     {
         file_put_contents($this->deduplicationStore, $record['datetime']->getTimestamp() . ':' . $record['level_name'] . ':' . preg_replace('{[\r\n].*}', '', $record['message']) . "\n", FILE_APPEND);
     }

vendor/monolog/monolog/src/Monolog/Handler/DoctrineCouchDBHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -13,7 +13,6 @@ namespace Monolog\Handler;
 
 use Monolog\Logger;
 use Monolog\Formatter\NormalizerFormatter;
-use Monolog\Formatter\FormatterInterface;
 use Doctrine\CouchDB\CouchDBClient;
 
 /**
@@ -25,7 +24,7 @@ class DoctrineCouchDBHandler extends AbstractProcessingHandler
 {
     private $client;
 
-    public function __construct(CouchDBClient $client, $level = Logger::DEBUG, bool $bubble = true)
+    public function __construct(CouchDBClient $client, $level = Logger::DEBUG, $bubble = true)
     {
         $this->client = $client;
         parent::__construct($level, $bubble);
@@ -34,12 +33,12 @@ class DoctrineCouchDBHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
         $this->client->postDocument($record['formatted']);
     }
 
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new NormalizerFormatter;
     }

vendor/monolog/monolog/src/Monolog/Handler/DynamoDbHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -13,7 +13,6 @@ namespace Monolog\Handler;
 
 use Aws\Sdk;
 use Aws\DynamoDb\DynamoDbClient;
-use Monolog\Formatter\FormatterInterface;
 use Aws\DynamoDb\Marshaler;
 use Monolog\Formatter\ScalarFormatter;
 use Monolog\Logger;
@@ -26,7 +25,7 @@ use Monolog\Logger;
  */
 class DynamoDbHandler extends AbstractProcessingHandler
 {
-    public const DATE_FORMAT = 'Y-m-d\TH:i:s.uO';
+    const DATE_FORMAT = 'Y-m-d\TH:i:s.uO';
 
     /**
      * @var DynamoDbClient
@@ -49,9 +48,12 @@ class DynamoDbHandler extends AbstractProcessingHandler
     protected $marshaler;
 
     /**
-     * @param int|string $level
+     * @param DynamoDbClient $client
+     * @param string         $table
+     * @param int            $level
+     * @param bool           $bubble
      */
-    public function __construct(DynamoDbClient $client, string $table, $level = Logger::DEBUG, bool $bubble = true)
+    public function __construct(DynamoDbClient $client, $table, $level = Logger::DEBUG, $bubble = true)
     {
         if (defined('Aws\Sdk::VERSION') && version_compare(Sdk::VERSION, '3.0', '>=')) {
             $this->version = 3;
@@ -69,7 +71,7 @@ class DynamoDbHandler extends AbstractProcessingHandler
     /**
      * {@inheritdoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
         $filtered = $this->filterEmptyFields($record['formatted']);
         if ($this->version === 3) {
@@ -78,13 +80,17 @@ class DynamoDbHandler extends AbstractProcessingHandler
             $formatted = $this->client->formatAttributes($filtered);
         }
 
-        $this->client->putItem([
+        $this->client->putItem(array(
             'TableName' => $this->table,
             'Item' => $formatted,
-        ]);
+        ));
     }
 
-    protected function filterEmptyFields(array $record): array
+    /**
+     * @param  array $record
+     * @return array
+     */
+    protected function filterEmptyFields(array $record)
     {
         return array_filter($record, function ($value) {
             return !empty($value) || false === $value || 0 === $value;
@@ -94,7 +100,7 @@ class DynamoDbHandler extends AbstractProcessingHandler
     /**
      * {@inheritdoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new ScalarFormatter(self::DATE_FORMAT);
     }

vendor/monolog/monolog/src/Monolog/Handler/ElasticaHandler.php

-<?php declare(strict_types=1);
-
-/*
- * This file is part of the Monolog package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Monolog\Handler;
-
-use Monolog\Formatter\FormatterInterface;
-use Monolog\Formatter\ElasticaFormatter;
-use Monolog\Logger;
-use Elastica\Client;
-use Elastica\Exception\ExceptionInterface;
-
-/**
- * Elastic Search handler
- *
- * Usage example:
- *
- *    $client = new \Elastica\Client();
- *    $options = array(
- *        'index' => 'elastic_index_name',
- *        'type' => 'elastic_doc_type',
- *    );
- *    $handler = new ElasticaHandler($client, $options);
- *    $log = new Logger('application');
- *    $log->pushHandler($handler);
- *
- * @author Jelle Vink <jelle.vink@gmail.com>
- */
-class ElasticaHandler extends AbstractProcessingHandler
-{
-    /**
-     * @var Client
-     */
-    protected $client;
-
-    /**
-     * @var array Handler config options
-     */
-    protected $options = [];
-
-    /**
-     * @param Client     $client  Elastica Client object
-     * @param array      $options Handler configuration
-     * @param int|string $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
-     */
-    public function __construct(Client $client, array $options = [], $level = Logger::DEBUG, bool $bubble = true)
-    {
-        parent::__construct($level, $bubble);
-        $this->client = $client;
-        $this->options = array_merge(
-            [
-                'index'          => 'monolog',      // Elastic index name
-                'type'           => 'record',       // Elastic document type
-                'ignore_error'   => false,          // Suppress Elastica exceptions
-            ],
-            $options
-        );
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    protected function write(array $record): void
-    {
-        $this->bulkSend([$record['formatted']]);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function setFormatter(FormatterInterface $formatter): HandlerInterface
-    {
-        if ($formatter instanceof ElasticaFormatter) {
-            return parent::setFormatter($formatter);
-        }
-
-        throw new \InvalidArgumentException('ElasticaHandler is only compatible with ElasticaFormatter');
-    }
-
-    public function getOptions(): array
-    {
-        return $this->options;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    protected function getDefaultFormatter(): FormatterInterface
-    {
-        return new ElasticaFormatter($this->options['index'], $this->options['type']);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function handleBatch(array $records): void
-    {
-        $documents = $this->getFormatter()->formatBatch($records);
-        $this->bulkSend($documents);
-    }
-
-    /**
-     * Use Elasticsearch bulk API to send list of documents
-     * @throws \RuntimeException
-     */
-    protected function bulkSend(array $documents): void
-    {
-        try {
-            $this->client->addDocuments($documents);
-        } catch (ExceptionInterface $e) {
-            if (!$this->options['ignore_error']) {
-                throw new \RuntimeException("Error sending messages to Elasticsearch", 0, $e);
-            }
-        }
-    }
-}

vendor/monolog/monolog/src/Monolog/Handler/ElasticsearchHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -11,37 +11,29 @@
 
 namespace Monolog\Handler;
 
-use Throwable;
-use RuntimeException;
-use Monolog\Logger;
 use Monolog\Formatter\FormatterInterface;
-use Monolog\Formatter\ElasticsearchFormatter;
-use InvalidArgumentException;
-use Elasticsearch\Common\Exceptions\RuntimeException as ElasticsearchRuntimeException;
-use Elasticsearch\Client;
+use Monolog\Formatter\ElasticaFormatter;
+use Monolog\Logger;
+use Elastica\Client;
+use Elastica\Exception\ExceptionInterface;
 
 /**
- * Elasticsearch handler
- *
- * @link https://www.elastic.co/guide/en/elasticsearch/client/php-api/current/index.html
- *
- * Simple usage example:
+ * Elastic Search handler
  *
- *    $client = \Elasticsearch\ClientBuilder::create()
- *        ->setHosts($hosts)
- *        ->build();
+ * Usage example:
  *
+ *    $client = new \Elastica\Client();
  *    $options = array(
  *        'index' => 'elastic_index_name',
- *        'type'  => 'elastic_doc_type',
+ *        'type' => 'elastic_doc_type',
  *    );
- *    $handler = new ElasticsearchHandler($client, $options);
+ *    $handler = new ElasticSearchHandler($client, $options);
  *    $log = new Logger('application');
  *    $log->pushHandler($handler);
  *
- * @author Avtandil Kikabidze <akalongman@gmail.com>
+ * @author Jelle Vink <jelle.vink@gmail.com>
  */
-class ElasticsearchHandler extends AbstractProcessingHandler
+class ElasticSearchHandler extends AbstractProcessingHandler
 {
     /**
      * @var Client
@@ -51,24 +43,24 @@ class ElasticsearchHandler extends AbstractProcessingHandler
     /**
      * @var array Handler config options
      */
-    protected $options = [];
+    protected $options = array();
 
     /**
-     * @param Client     $client  Elasticsearch Client object
-     * @param array      $options Handler configuration
-     * @param string|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
+     * @param Client $client  Elastica Client object
+     * @param array  $options Handler configuration
+     * @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
      */
-    public function __construct(Client $client, array $options = [], $level = Logger::DEBUG, bool $bubble = true)
+    public function __construct(Client $client, array $options = array(), $level = Logger::DEBUG, $bubble = true)
     {
         parent::__construct($level, $bubble);
         $this->client = $client;
         $this->options = array_merge(
-            [
-                'index'        => 'monolog', // Elastic index name
-                'type'         => '_doc',    // Elastic document type
-                'ignore_error' => false,     // Suppress Elasticsearch exceptions
-            ],
+            array(
+                'index'          => 'monolog',      // Elastic index name
+                'type'           => 'record',       // Elastic document type
+                'ignore_error'   => false,          // Suppress Elastica exceptions
+            ),
             $options
         );
     }
@@ -76,29 +68,27 @@ class ElasticsearchHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
-        $this->bulkSend([$record['formatted']]);
+        $this->bulkSend(array($record['formatted']));
     }
 
     /**
      * {@inheritdoc}
      */
-    public function setFormatter(FormatterInterface $formatter): HandlerInterface
+    public function setFormatter(FormatterInterface $formatter)
     {
-        if ($formatter instanceof ElasticsearchFormatter) {
+        if ($formatter instanceof ElasticaFormatter) {
             return parent::setFormatter($formatter);
         }
-
-        throw new InvalidArgumentException('ElasticsearchHandler is only compatible with ElasticsearchFormatter');
+        throw new \InvalidArgumentException('ElasticSearchHandler is only compatible with ElasticaFormatter');
     }
 
     /**
      * Getter options
-     *
      * @return array
      */
-    public function getOptions(): array
+    public function getOptions()
     {
         return $this->options;
     }
@@ -106,15 +96,15 @@ class ElasticsearchHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
-        return new ElasticsearchFormatter($this->options['index'], $this->options['type']);
+        return new ElasticaFormatter($this->options['index'], $this->options['type']);
     }
 
     /**
      * {@inheritdoc}
      */
-    public function handleBatch(array $records): void
+    public function handleBatch(array $records)
     {
         $documents = $this->getFormatter()->formatBatch($records);
         $this->bulkSend($documents);
@@ -122,68 +112,17 @@ class ElasticsearchHandler extends AbstractProcessingHandler
 
     /**
      * Use Elasticsearch bulk API to send list of documents
-     *
-     * @param  array             $records
+     * @param  array             $documents
      * @throws \RuntimeException
      */
-    protected function bulkSend(array $records): void
+    protected function bulkSend(array $documents)
     {
         try {
-            $params = [
-                'body' => [],
-            ];
-
-            foreach ($records as $record) {
-                $params['body'][] = [
-                    'index' => [
-                        '_index' => $record['_index'],
-                        '_type'  => $record['_type'],
-                    ],
-                ];
-                unset($record['_index'], $record['_type']);
-
-                $params['body'][] = $record;
-            }
-
-            $responses = $this->client->bulk($params);
-
-            if ($responses['errors'] === true) {
-                throw $this->createExceptionFromResponses($responses);
-            }
-        } catch (Throwable $e) {
-            if (! $this->options['ignore_error']) {
-                throw new RuntimeException('Error sending messages to Elasticsearch', 0, $e);
+            $this->client->addDocuments($documents);
+        } catch (ExceptionInterface $e) {
+            if (!$this->options['ignore_error']) {
+                throw new \RuntimeException("Error sending messages to Elasticsearch", 0, $e);
             }
         }
     }
-
-    /**
-     * Creates elasticsearch exception from responses array
-     *
-     * Only the first error is converted into an exception.
-     *
-     * @param array $responses returned by $this->client->bulk()
-     */
-    protected function createExceptionFromResponses(array $responses): ElasticsearchRuntimeException
-    {
-        foreach ($responses['items'] ?? [] as $item) {
-            if (isset($item['index']['error'])) {
-                return $this->createExceptionFromError($item['index']['error']);
-            }
-        }
-
-        return new ElasticsearchRuntimeException('Elasticsearch failed to index one or more records.');
-    }
-
-    /**
-     * Creates elasticsearch exception from error array
-     *
-     * @param array $error
-     */
-    protected function createExceptionFromError(array $error): ElasticsearchRuntimeException
-    {
-        $previous = isset($error['caused_by']) ? $this->createExceptionFromError($error['caused_by']) : null;
-
-        return new ElasticsearchRuntimeException($error['type'] . ': ' . $error['reason'], 0, $previous);
-    }
 }

vendor/monolog/monolog/src/Monolog/Handler/ErrorLogHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -12,7 +12,6 @@
 namespace Monolog\Handler;
 
 use Monolog\Formatter\LineFormatter;
-use Monolog\Formatter\FormatterInterface;
 use Monolog\Logger;
 
 /**
@@ -22,25 +21,24 @@ use Monolog\Logger;
  */
 class ErrorLogHandler extends AbstractProcessingHandler
 {
-    public const OPERATING_SYSTEM = 0;
-    public const SAPI = 4;
+    const OPERATING_SYSTEM = 0;
+    const SAPI = 4;
 
     protected $messageType;
     protected $expandNewlines;
 
     /**
-     * @param int        $messageType    Says where the error should go.
-     * @param int|string $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
-     * @param bool       $expandNewlines If set to true, newlines in the message will be expanded to be take multiple log entries
+     * @param int  $messageType    Says where the error should go.
+     * @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
+     * @param bool $expandNewlines If set to true, newlines in the message will be expanded to be take multiple log entries
      */
-    public function __construct(int $messageType = self::OPERATING_SYSTEM, $level = Logger::DEBUG, bool $bubble = true, bool $expandNewlines = false)
+    public function __construct($messageType = self::OPERATING_SYSTEM, $level = Logger::DEBUG, $bubble = true, $expandNewlines = false)
     {
         parent::__construct($level, $bubble);
 
-        if (false === in_array($messageType, self::getAvailableTypes(), true)) {
+        if (false === in_array($messageType, self::getAvailableTypes())) {
             $message = sprintf('The given message type "%s" is not supported', print_r($messageType, true));
-
             throw new \InvalidArgumentException($message);
         }
 
@@ -51,18 +49,18 @@ class ErrorLogHandler extends AbstractProcessingHandler
     /**
      * @return array With all available types
      */
-    public static function getAvailableTypes(): array
+    public static function getAvailableTypes()
     {
-        return [
+        return array(
             self::OPERATING_SYSTEM,
             self::SAPI,
-        ];
+        );
     }
 
     /**
      * {@inheritDoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new LineFormatter('[%datetime%] %channel%.%level_name%: %message% %context% %extra%');
     }
@@ -70,17 +68,15 @@ class ErrorLogHandler extends AbstractProcessingHandler
     /**
      * {@inheritdoc}
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
-        if (!$this->expandNewlines) {
+        if ($this->expandNewlines) {
+            $lines = preg_split('{[\r\n]+}', (string) $record['formatted']);
+            foreach ($lines as $line) {
+                error_log($line, $this->messageType);
+            }
+        } else {
             error_log((string) $record['formatted'], $this->messageType);
-
-            return;
-        }
-
-        $lines = preg_split('{[\r\n]+}', (string) $record['formatted']);
-        foreach ($lines as $line) {
-            error_log($line, $this->messageType);
         }
     }
 }

vendor/monolog/monolog/src/Monolog/Handler/FallbackGroupHandler.php

-<?php declare(strict_types=1);
-
-/*
- * This file is part of the Monolog package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Monolog\Handler;
-
-use Throwable;
-
-class FallbackGroupHandler extends GroupHandler
-{
-    /**
-     * {@inheritdoc}
-     */
-    public function handle(array $record): bool
-    {
-        if ($this->processors) {
-            $record = $this->processRecord($record);
-        }
-        foreach ($this->handlers as $handler) {
-            try {
-                $handler->handle($record);
-                break;
-            } catch (Throwable $e) {
-                // What throwable?
-            }
-        }
-        return false === $this->bubble;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function handleBatch(array $records): void
-    {
-        if ($this->processors) {
-            $processed = [];
-            foreach ($records as $record) {
-                $processed[] = $this->processRecord($record);
-            }
-            $records = $processed;
-        }
-
-        foreach ($this->handlers as $handler) {
-            try {
-                $handler->handleBatch($records);
-                break;
-            } catch (Throwable $e) {
-                // What throwable?
-            }
-        }
-    }
-}

vendor/monolog/monolog/src/Monolog/Handler/FilterHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -12,7 +12,6 @@
 namespace Monolog\Handler;
 
 use Monolog\Logger;
-use Monolog\ResettableInterface;
 use Monolog\Formatter\FormatterInterface;
 
 /**
@@ -23,10 +22,8 @@ use Monolog\Formatter\FormatterInterface;
  * @author Hennadiy Verkh
  * @author Jordi Boggiano <j.boggiano@seld.be>
  */
-class FilterHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface, FormattableHandlerInterface
+class FilterHandler extends AbstractHandler
 {
-    use ProcessableHandlerTrait;
-
     /**
      * Handler or factory callable($record, $this)
      *
@@ -51,10 +48,10 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
     /**
      * @param callable|HandlerInterface $handler        Handler or factory callable($record|null, $filterHandler).
      * @param int|array                 $minLevelOrList A list of levels to accept or a minimum level if maxLevel is provided
-     * @param int|string                $maxLevel       Maximum level to accept, only used if $minLevelOrList is not an array
+     * @param int                       $maxLevel       Maximum level to accept, only used if $minLevelOrList is not an array
      * @param bool                      $bubble         Whether the messages that are handled can bubble up the stack or not
      */
-    public function __construct($handler, $minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY, bool $bubble = true)
+    public function __construct($handler, $minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY, $bubble = true)
     {
         $this->handler  = $handler;
         $this->bubble   = $bubble;
@@ -65,7 +62,10 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
         }
     }
 
-    public function getAcceptedLevels(): array
+    /**
+     * @return array
+     */
+    public function getAcceptedLevels()
     {
         return array_flip($this->acceptedLevels);
     }
@@ -74,7 +74,7 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
      * @param int|string|array $minLevelOrList A list of levels to accept or a minimum level or level name if maxLevel is provided
      * @param int|string       $maxLevel       Maximum level or level name to accept, only used if $minLevelOrList is not an array
      */
-    public function setAcceptedLevels($minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY): self
+    public function setAcceptedLevels($minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY)
     {
         if (is_array($minLevelOrList)) {
             $acceptedLevels = array_map('Monolog\Logger::toMonologLevel', $minLevelOrList);
@@ -86,14 +86,12 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
             }));
         }
         $this->acceptedLevels = array_flip($acceptedLevels);
-
-        return $this;
     }
 
     /**
      * {@inheritdoc}
      */
-    public function isHandling(array $record): bool
+    public function isHandling(array $record)
     {
         return isset($this->acceptedLevels[$record['level']]);
     }
@@ -101,14 +99,16 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
     /**
      * {@inheritdoc}
      */
-    public function handle(array $record): bool
+    public function handle(array $record)
     {
         if (!$this->isHandling($record)) {
             return false;
         }
 
         if ($this->processors) {
-            $record = $this->processRecord($record);
+            foreach ($this->processors as $processor) {
+                $record = call_user_func($processor, $record);
+            }
         }
 
         $this->getHandler($record)->handle($record);
@@ -119,9 +119,9 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
     /**
      * {@inheritdoc}
      */
-    public function handleBatch(array $records): void
+    public function handleBatch(array $records)
     {
-        $filtered = [];
+        $filtered = array();
         foreach ($records as $record) {
             if ($this->isHandling($record)) {
                 $filtered[] = $record;
@@ -155,7 +155,7 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
     /**
      * {@inheritdoc}
      */
-    public function setFormatter(FormatterInterface $formatter): HandlerInterface
+    public function setFormatter(FormatterInterface $formatter)
     {
         $this->getHandler()->setFormatter($formatter);
 
@@ -165,13 +165,8 @@ class FilterHandler extends Handler implements ProcessableHandlerInterface, Rese
     /**
      * {@inheritdoc}
      */
-    public function getFormatter(): FormatterInterface
+    public function getFormatter()
     {
         return $this->getHandler()->getFormatter();
     }
-
-    public function reset()
-    {
-        $this->resetProcessors();
-    }
 }

vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -20,6 +20,9 @@ interface ActivationStrategyInterface
 {
     /**
      * Returns whether the given record activates the handler.
+     *
+     * @param  array   $record
+     * @return bool
      */
-    public function isHandlerActivated(array $record): bool;
+    public function isHandlerActivated(array $record);
 }

vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -35,27 +35,20 @@ use Monolog\Logger;
  */
 class ChannelLevelActivationStrategy implements ActivationStrategyInterface
 {
-    /**
-     * @var int
-     */
     private $defaultActionLevel;
-
-    /**
-     * @var array
-     */
     private $channelToActionLevel;
 
     /**
-     * @param int|string $defaultActionLevel   The default action level to be used if the record's category doesn't match any
-     * @param array      $channelToActionLevel An array that maps channel names to action levels.
+     * @param int   $defaultActionLevel   The default action level to be used if the record's category doesn't match any
+     * @param array $channelToActionLevel An array that maps channel names to action levels.
      */
-    public function __construct($defaultActionLevel, array $channelToActionLevel = [])
+    public function __construct($defaultActionLevel, $channelToActionLevel = array())
     {
         $this->defaultActionLevel = Logger::toMonologLevel($defaultActionLevel);
         $this->channelToActionLevel = array_map('Monolog\Logger::toMonologLevel', $channelToActionLevel);
     }
 
-    public function isHandlerActivated(array $record): bool
+    public function isHandlerActivated(array $record)
     {
         if (isset($this->channelToActionLevel[$record['channel']])) {
             return $record['level'] >= $this->channelToActionLevel[$record['channel']];

vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -20,20 +20,14 @@ use Monolog\Logger;
  */
 class ErrorLevelActivationStrategy implements ActivationStrategyInterface
 {
-    /**
-     * @var int
-     */
     private $actionLevel;
 
-    /**
-     * @param int|string $actionLevel Level or name or value
-     */
     public function __construct($actionLevel)
     {
         $this->actionLevel = Logger::toMonologLevel($actionLevel);
     }
 
-    public function isHandlerActivated(array $record): bool
+    public function isHandlerActivated(array $record)
     {
         return $record['level'] >= $this->actionLevel;
     }

vendor/monolog/monolog/src/Monolog/Handler/FingersCrossedHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -24,37 +24,30 @@ use Monolog\Formatter\FormatterInterface;
  * Only requests which actually trigger an error (or whatever your actionLevel is) will be
  * in the logs, but they will contain all records, not only those above the level threshold.
  *
- * You can then have a passthruLevel as well which means that at the end of the request,
- * even if it did not get activated, it will still send through log records of e.g. at least a
- * warning level.
- *
  * You can find the various activation strategies in the
  * Monolog\Handler\FingersCrossed\ namespace.
  *
  * @author Jordi Boggiano <j.boggiano@seld.be>
  */
-class FingersCrossedHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface, FormattableHandlerInterface
+class FingersCrossedHandler extends AbstractHandler
 {
-    use ProcessableHandlerTrait;
-
     protected $handler;
     protected $activationStrategy;
     protected $buffering = true;
     protected $bufferSize;
-    protected $buffer = [];
+    protected $buffer = array();
     protected $stopBuffering;
     protected $passthruLevel;
-    protected $bubble;
 
     /**
-     * @param callable|HandlerInterface              $handler            Handler or factory callable($record|null, $fingersCrossedHandler).
-     * @param int|string|ActivationStrategyInterface $activationStrategy Strategy which determines when this handler takes action, or a level name/value at which the handler is activated
-     * @param int                                    $bufferSize         How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
-     * @param bool                                   $bubble             Whether the messages that are handled can bubble up the stack or not
-     * @param bool                                   $stopBuffering      Whether the handler should stop buffering after being triggered (default true)
-     * @param int|string                             $passthruLevel      Minimum level to always flush to handler on close, even if strategy not triggered
+     * @param callable|HandlerInterface       $handler            Handler or factory callable($record|null, $fingersCrossedHandler).
+     * @param int|ActivationStrategyInterface $activationStrategy Strategy which determines when this handler takes action
+     * @param int                             $bufferSize         How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
+     * @param bool                            $bubble             Whether the messages that are handled can bubble up the stack or not
+     * @param bool                            $stopBuffering      Whether the handler should stop buffering after being triggered (default true)
+     * @param int                             $passthruLevel      Minimum level to always flush to handler on close, even if strategy not triggered
      */
-    public function __construct($handler, $activationStrategy = null, int $bufferSize = 0, bool $bubble = true, bool $stopBuffering = true, $passthruLevel = null)
+    public function __construct($handler, $activationStrategy = null, $bufferSize = 0, $bubble = true, $stopBuffering = true, $passthruLevel = null)
     {
         if (null === $activationStrategy) {
             $activationStrategy = new ErrorLevelActivationStrategy(Logger::WARNING);
@@ -83,7 +76,7 @@ class FingersCrossedHandler extends Handler implements ProcessableHandlerInterfa
     /**
      * {@inheritdoc}
      */
-    public function isHandling(array $record): bool
+    public function isHandling(array $record)
     {
         return true;
     }
@@ -91,23 +84,24 @@ class FingersCrossedHandler extends Handler implements ProcessableHandlerInterfa
     /**
      * Manually activate this logger regardless of the activation strategy
      */
-    public function activate(): void
+    public function activate()
     {
         if ($this->stopBuffering) {
             $this->buffering = false;
         }
-
         $this->getHandler(end($this->buffer) ?: null)->handleBatch($this->buffer);
-        $this->buffer = [];
+        $this->buffer = array();
     }
 
     /**
      * {@inheritdoc}
      */
-    public function handle(array $record): bool
+    public function handle(array $record)
     {
         if ($this->processors) {
-            $record = $this->processRecord($record);
+            foreach ($this->processors as $processor) {
+                $record = call_user_func($processor, $record);
+            }
         }
 
         if ($this->buffering) {
@@ -128,18 +122,16 @@ class FingersCrossedHandler extends Handler implements ProcessableHandlerInterfa
     /**
      * {@inheritdoc}
      */
-    public function close(): void
+    public function close()
     {
         $this->flushBuffer();
-
-        $this->handler->close();
     }
 
     public function reset()
     {
         $this->flushBuffer();
 
-        $this->resetProcessors();
+        parent::reset();
 
         if ($this->getHandler() instanceof ResettableInterface) {
             $this->getHandler()->reset();
@@ -151,16 +143,16 @@ class FingersCrossedHandler extends Handler implements ProcessableHandlerInterfa
      *
      * It also resets the handler to its initial buffering state.
      */
-    public function clear(): void
+    public function clear()
     {
-        $this->buffer = [];
+        $this->buffer = array();
         $this->reset();
     }
 
     /**
      * Resets the state of the handler. Stops forwarding records to the wrapped handler.
      */
-    private function flushBuffer(): void
+    private function flushBuffer()
     {
         if (null !== $this->passthruLevel) {
             $level = $this->passthruLevel;
@@ -172,7 +164,7 @@ class FingersCrossedHandler extends Handler implements ProcessableHandlerInterfa
             }
         }
 
-        $this->buffer = [];
+        $this->buffer = array();
         $this->buffering = true;
     }
 
@@ -198,7 +190,7 @@ class FingersCrossedHandler extends Handler implements ProcessableHandlerInterfa
     /**
      * {@inheritdoc}
      */
-    public function setFormatter(FormatterInterface $formatter): HandlerInterface
+    public function setFormatter(FormatterInterface $formatter)
     {
         $this->getHandler()->setFormatter($formatter);
 
@@ -208,7 +200,7 @@ class FingersCrossedHandler extends Handler implements ProcessableHandlerInterfa
     /**
      * {@inheritdoc}
      */
-    public function getFormatter(): FormatterInterface
+    public function getFormatter()
     {
         return $this->getHandler()->getFormatter();
     }

vendor/monolog/monolog/src/Monolog/Handler/FirePHPHandler.php

-<?php declare(strict_types=1);
+<?php
 
 /*
  * This file is part of the Monolog package.
@@ -12,7 +12,6 @@
 namespace Monolog\Handler;
 
 use Monolog\Formatter\WildfireFormatter;
-use Monolog\Formatter\FormatterInterface;
 
 /**
  * Simple FirePHP Handler (http://www.firephp.org/), which uses the Wildfire protocol.
@@ -21,27 +20,25 @@ use Monolog\Formatter\FormatterInterface;
  */
 class FirePHPHandler extends AbstractProcessingHandler
 {
-    use WebRequestRecognizerTrait;
-
     /**
      * WildFire JSON header message format
      */
-    protected const PROTOCOL_URI = 'http://meta.wildfirehq.org/Protocol/JsonStream/0.2';
+    const PROTOCOL_URI = 'http://meta.wildfirehq.org/Protocol/JsonStream/0.2';
 
     /**
      * FirePHP structure for parsing messages & their presentation
      */
-    protected const STRUCTURE_URI = 'http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1';
+    const STRUCTURE_URI = 'http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1';
 
     /**
      * Must reference a "known" plugin, otherwise headers won't display in FirePHP
      */
-    protected const PLUGIN_URI = 'http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.3';
+    const PLUGIN_URI = 'http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.3';
 
     /**
      * Header prefix for Wildfire to recognize & parse headers
      */
-    protected const HEADER_PREFIX = 'X-Wf';
+    const HEADER_PREFIX = 'X-Wf';
 
     /**
      * Whether or not Wildfire vendor-specific headers have been generated & sent yet
@@ -63,24 +60,26 @@ class FirePHPHandler extends AbstractProcessingHandler
      * @param  string $message Log message
      * @return array  Complete header string ready for the client as key and message as value
      */
-    protected function createHeader(array $meta, string $message): array
+    protected function createHeader(array $meta, $message)
     {
-        $header = sprintf('%s-%s', static::HEADER_PREFIX, join('-', $meta));
+        $header = sprintf('%s-%s', self::HEADER_PREFIX, join('-', $meta));
 
-        return [$header => $message];
+        return array($header => $message);
     }
 
     /**
      * Creates message header from record
      *
      * @see createHeader()
+     * @param  array  $record
+     * @return string
      */
-    protected function createRecordHeader(array $record): array
+    protected function createRecordHeader(array $record)
     {
         // Wildfire is extensible to support multiple protocols & plugins in a single request,
         // but we're not taking advantage of that (yet), so we're using "1" for simplicity's sake.
         return $this->createHeader(
-            [1, 1, 1, self::$messageIndex++],
+            array(1, 1, 1, self::$messageIndex++),
             $record['formatted']
         );
     }
@@ -88,7 +87,7 @@ class FirePHPHandler extends AbstractProcessingHandler
     /**
      * {@inheritDoc}
      */
-    protected function getDefaultFormatter(): FormatterInterface
+    protected function getDefaultFormatter()
     {
         return new WildfireFormatter();
     }
@@ -98,21 +97,25 @@ class FirePHPHandler extends AbstractProcessingHandler
      *
      * @see createHeader()
      * @see sendHeader()
+     * @return array
      */
-    protected function getInitHeaders(): array
+    protected function getInitHeaders()
     {
         // Initial payload consists of required headers for Wildfire
         return array_merge(
-            $this->createHeader(['Protocol', 1], static::PROTOCOL_URI),
-            $this->createHeader([1, 'Structure', 1], static::STRUCTURE_URI),
-            $this->createHeader([1, 'Plugin', 1], static::PLUGIN_URI)
+            $this->createHeader(array('Protocol', 1), self::PROTOCOL_URI),
+            $this->createHeader(array(1, 'Structure', 1), self::STRUCTURE_URI),
+            $this->createHeader(array(1, 'Plugin', 1), self::PLUGIN_URI)
         );
     }
 
     /**
      * Send header string to the client
+     *
+     * @param string $header
+     * @param string $content
      */
-    protected function sendHeader(string $header, string $content): void
+    protected function sendHeader($header, $content)
     {
         if (!headers_sent() && self::$sendHeaders) {
             header(sprintf('%s: %s', $header, $content));
@@ -126,9 +129,9 @@ class FirePHPHandler extends AbstractProcessingHandler
      * @see sendInitHeaders()
      * @param array $record
      */
-    protected function write(array $record): void
+    protected function write(array $record)
     {
-        if (!self::$sendHeaders || !$this->isWebRequest()) {
+        if (!self::$sendHeaders) {
             return;
         }
 
@@ -154,8 +157,10 @@ class FirePHPHandler extends AbstractProcessingHandler
 
     /**
      * Verifies if the headers are accepted by the current user agent
+     *
+     * @return bool
      */
-    protected function headersAccepted(): bool
+    protected function headersAccepted()
     {
         if (!empty($_SERVER['HTTP_USER_AGENT']) && preg_match('{\bFirePHP/\d+\.\d+\b}', $_SERVER['HTTP_USER_AGENT'])) {
             return true;
@@ -163,4 +168,28 @@ class FirePHPHandler extends AbstractProcessingHandler
 
         return isset($_SERVER['HTTP_X_FIREPHP_VERSION']);
     }
+
+    /**
+     * BC getter for the sendHeaders property that has been made static
+     */
+    public function __get($property)
+    {
+        if ('sendHeaders' !== $property) {
+            throw new \InvalidArgumentException('Undefined property '.$property);
+        }
+
+        return static::$sendHeaders;
+    }
+
+    /**
+     * BC setter for the sendHeaders property that has been made static
+     */
+    public function __set($property, $value)
+    {
+        if ('sendHeaders' !== $property) {
+            throw new \InvalidArgumentException('Undefined property '.$property);
+        }
+
+        static::$sendHeaders = $value;
+    }
 }