feat: add S3-compatible storage provider (MinIO, Ceph, R2, etc.)
Adds a new 'S3-Compatible Storage' provider that works with any
S3-API-compatible object storage service, including MinIO, Ceph,
Cloudflare R2, Backblaze B2, and others.
Changes:
- New provider class: classes/providers/storage/s3-compatible-provider.php
- Provider key: s3compatible
- Reads user-configured endpoint URL from settings
- Uses path-style URL access (required by most S3-compatible services)
- Supports credentials via AS3CF_S3COMPAT_ACCESS_KEY_ID /
AS3CF_S3COMPAT_SECRET_ACCESS_KEY wp-config.php constants
- Disables AWS-specific features (Block Public Access, Object Ownership)
- New provider SVG icons (s3compatible.svg, -link.svg, -round.svg)
- Registered provider in main plugin class with endpoint setting support
- Updated StorageProviderSubPage to show endpoint URL input for S3-compatible
- Built pro settings bundle with rollup (Svelte 4.2.19)
- Added package.json and updated rollup.config.mjs for pro-only builds
This commit is contained in:
641
vendor/Gcp/monolog/monolog/CHANGELOG.md
vendored
Normal file
641
vendor/Gcp/monolog/monolog/CHANGELOG.md
vendored
Normal file
@@ -0,0 +1,641 @@
|
||||
### 2.10.0 (2024-11-12)
|
||||
|
||||
* Added `$fileOpenMode` to `StreamHandler` to define a custom fopen mode to open the log file (#1913)
|
||||
* Fixed `StreamHandler` handling of write failures so that it now closes/reopens the stream and retries the write once before failing (#1882)
|
||||
* Fixed `StreamHandler` error handler causing issues if a stream handler triggers an error (#1866)
|
||||
* Fixed `JsonFormatter` handling of incomplete classes (#1834)
|
||||
* Fixed `RotatingFileHandler` bug where rotation could sometimes not happen correctly (#1905)
|
||||
|
||||
### 2.9.3 (2024-04-12)
|
||||
|
||||
* Fixed PHP 8.4 deprecation warnings (#1874)
|
||||
|
||||
### 2.9.2 (2023-10-27)
|
||||
|
||||
* Fixed display_errors parsing in ErrorHandler which did not support string values (#1804)
|
||||
* Fixed bug where the previous error handler would not be restored in some cases where StreamHandler fails (#1815)
|
||||
* Fixed normalization error when normalizing incomplete classes (#1833)
|
||||
|
||||
### 2.9.1 (2023-02-06)
|
||||
|
||||
* Fixed Logger not being serializable anymore (#1792)
|
||||
|
||||
### 2.9.0 (2023-02-05)
|
||||
|
||||
* Deprecated FlowdockHandler & Formatter as the flowdock service was shutdown (#1748)
|
||||
* Added support for enum context values in PsrLogMessageProcessor (#1773)
|
||||
* Added graylog2/gelf-php 2.x support (#1747)
|
||||
* Improved `BrowserConsoleHandler` logging to use more appropriate methods than just console.log in the browser (#1739)
|
||||
* Fixed `WhatFailureGroupHandler` not catching errors happening inside `close()` (#1791)
|
||||
* Fixed datetime field in `GoogleCloudLoggingFormatter` (#1758)
|
||||
* Fixed infinite loop detection within Fibers (#1753)
|
||||
* Fixed `AmqpHandler->setExtraAttributes` not working with buffering handler wrappers (#1781)
|
||||
|
||||
### 2.8.0 (2022-07-24)
|
||||
|
||||
* Deprecated `CubeHandler` and `PHPConsoleHandler` as both projects are abandoned and those should not be used anymore (#1734)
|
||||
* Added RFC 5424 level (`7` to `0`) support to `Logger::log` and `Logger::addRecord` to increase interoperability (#1723)
|
||||
* Added support for `__toString` for objects which are not json serializable in `JsonFormatter` (#1733)
|
||||
* Added `GoogleCloudLoggingFormatter` (#1719)
|
||||
* Added support for Predis 2.x (#1732)
|
||||
* Added `AmqpHandler->setExtraAttributes` to allow configuring attributes when using an AMQPExchange (#1724)
|
||||
* Fixed serialization/unserialization of handlers to make sure private properties are included (#1727)
|
||||
* Fixed allowInlineLineBreaks in LineFormatter causing issues with windows paths containing `\n` or `\r` sequences (#1720)
|
||||
* Fixed max normalization depth not being taken into account when formatting exceptions with a deep chain of previous exceptions (#1726)
|
||||
* Fixed PHP 8.2 deprecation warnings (#1722)
|
||||
* Fixed rare race condition or filesystem issue where StreamHandler is unable to create the directory the log should go into yet it exists already (#1678)
|
||||
|
||||
### 2.7.0 (2022-06-09)
|
||||
|
||||
* Added `$datetime` parameter to `Logger::addRecord` as low level API to allow logging into the past or future (#1682)
|
||||
* Added `Logger::useLoggingLoopDetection` to allow disabling cyclic logging detection in concurrent frameworks (#1681)
|
||||
* Fixed handling of fatal errors if callPrevious is disabled in ErrorHandler (#1670)
|
||||
* Marked the reusable `Monolog\Test\TestCase` class as `@internal` to make sure PHPStorm does not show it above PHPUnit, you may still use it to test your own handlers/etc though (#1677)
|
||||
* Fixed RotatingFileHandler issue when the date format contained slashes (#1671)
|
||||
|
||||
### 2.6.0 (2022-05-10)
|
||||
|
||||
* Deprecated `SwiftMailerHandler`, use `SymfonyMailerHandler` instead
|
||||
* Added `SymfonyMailerHandler` (#1663)
|
||||
* Added ElasticSearch 8.x support to the ElasticsearchHandler (#1662)
|
||||
* Added a way to filter/modify stack traces in LineFormatter (#1665)
|
||||
* Fixed UdpSocket not being able to reopen/reconnect after close()
|
||||
* Fixed infinite loops if a Handler is triggering logging while handling log records
|
||||
|
||||
### 2.5.0 (2022-04-08)
|
||||
|
||||
* Added `callType` to IntrospectionProcessor (#1612)
|
||||
* Fixed AsMonologProcessor syntax to be compatible with PHP 7.2 (#1651)
|
||||
|
||||
### 2.4.0 (2022-03-14)
|
||||
|
||||
* Added [`Monolog\LogRecord`](src/Monolog/LogRecord.php) interface that can be used to type-hint records like `array|\Monolog\LogRecord $record` to be forward compatible with the upcoming Monolog 3 changes
|
||||
* Added `includeStacktraces` constructor params to LineFormatter & JsonFormatter (#1603)
|
||||
* Added `persistent`, `timeout`, `writingTimeout`, `connectionTimeout`, `chunkSize` constructor params to SocketHandler and derivatives (#1600)
|
||||
* Added `AsMonologProcessor` PHP attribute which can help autowiring / autoconfiguration of processors if frameworks / integrations decide to make use of it. This is useless when used purely with Monolog (#1637)
|
||||
* Added support for keeping native BSON types as is in MongoDBFormatter (#1620)
|
||||
* Added support for a `user_agent` key in WebProcessor, disabled by default but you can use it by configuring the $extraFields you want (#1613)
|
||||
* Added support for username/userIcon in SlackWebhookHandler (#1617)
|
||||
* Added extension points to BrowserConsoleHandler (#1593)
|
||||
* Added record message/context/extra info to exceptions thrown when a StreamHandler cannot open its stream to avoid completely losing the data logged (#1630)
|
||||
* Fixed error handler signature to accept a null $context which happens with internal PHP errors (#1614)
|
||||
* Fixed a few setter methods not returning `self` (#1609)
|
||||
* Fixed handling of records going over the max Telegram message length (#1616)
|
||||
|
||||
### 2.3.5 (2021-10-01)
|
||||
|
||||
* Fixed regression in StreamHandler since 2.3.3 on systems with the memory_limit set to >=20GB (#1592)
|
||||
|
||||
### 2.3.4 (2021-09-15)
|
||||
|
||||
* Fixed support for psr/log 3.x (#1589)
|
||||
|
||||
### 2.3.3 (2021-09-14)
|
||||
|
||||
* Fixed memory usage when using StreamHandler and calling stream_get_contents on the resource you passed to it (#1578, #1577)
|
||||
* Fixed support for psr/log 2.x (#1587)
|
||||
* Fixed some type annotations
|
||||
|
||||
### 2.3.2 (2021-07-23)
|
||||
|
||||
* Fixed compatibility with PHP 7.2 - 7.4 when experiencing PCRE errors (#1568)
|
||||
|
||||
### 2.3.1 (2021-07-14)
|
||||
|
||||
* Fixed Utils::getClass handling of anonymous classes not being fully compatible with PHP 8 (#1563)
|
||||
* Fixed some `@inheritDoc` annotations having the wrong case
|
||||
|
||||
### 2.3.0 (2021-07-05)
|
||||
|
||||
* Added a ton of PHPStan type annotations as well as type aliases on Monolog\Logger for Record, Level and LevelName that you can import (#1557)
|
||||
* Added ability to customize date format when using JsonFormatter (#1561)
|
||||
* Fixed FilterHandler not calling reset on its internal handler when reset() is called on it (#1531)
|
||||
* Fixed SyslogUdpHandler not setting the timezone correctly on DateTimeImmutable instances (#1540)
|
||||
* Fixed StreamHandler thread safety - chunk size set to 2GB now to avoid interlacing when doing concurrent writes (#1553)
|
||||
|
||||
### 2.2.0 (2020-12-14)
|
||||
|
||||
* Added JSON_PARTIAL_OUTPUT_ON_ERROR to default json encoding flags, to avoid dropping entire context data or even records due to an invalid subset of it somewhere
|
||||
* Added setDateFormat to NormalizerFormatter (and Line/Json formatters by extension) to allow changing this after object creation
|
||||
* Added RedisPubSubHandler to log records to a Redis channel using PUBLISH
|
||||
* Added support for Elastica 7, and deprecated the $type argument of ElasticaFormatter which is not in use anymore as of Elastica 7
|
||||
* Added support for millisecond write timeouts in SocketHandler, you can now pass floats to setWritingTimeout, e.g. 0.2 is 200ms
|
||||
* Added support for unix sockets in SyslogUdpHandler (set $port to 0 to make the $host a unix socket)
|
||||
* Added handleBatch support for TelegramBotHandler
|
||||
* Added RFC5424e extended date format including milliseconds to SyslogUdpHandler
|
||||
* Added support for configuring handlers with numeric level values in strings (coming from e.g. env vars)
|
||||
* Fixed Wildfire/FirePHP/ChromePHP handling of unicode characters
|
||||
* Fixed PHP 8 issues in SyslogUdpHandler
|
||||
* Fixed internal type error when mbstring is missing
|
||||
|
||||
### 2.1.1 (2020-07-23)
|
||||
|
||||
* Fixed removing of json encoding options
|
||||
* Fixed type hint of $level not accepting strings in SendGridHandler and OverflowHandler
|
||||
* Fixed SwiftMailerHandler not accepting email templates with an empty subject
|
||||
* Fixed array access on null in RavenHandler
|
||||
* Fixed unique_id in WebProcessor not being disableable
|
||||
|
||||
### 2.1.0 (2020-05-22)
|
||||
|
||||
* Added `JSON_INVALID_UTF8_SUBSTITUTE` to default json flags, so that invalid UTF8 characters now get converted to [<EFBFBD>](https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character) instead of being converted from ISO-8859-15 to UTF8 as it was before, which was hardly a comprehensive solution
|
||||
* Added `$ignoreEmptyContextAndExtra` option to JsonFormatter to skip empty context/extra entirely from the output
|
||||
* Added `$parseMode`, `$disableWebPagePreview` and `$disableNotification` options to TelegramBotHandler
|
||||
* Added tentative support for PHP 8
|
||||
* NormalizerFormatter::addJsonEncodeOption and removeJsonEncodeOption are now public to allow modifying default json flags
|
||||
* Fixed GitProcessor type error when there is no git repo present
|
||||
* Fixed normalization of SoapFault objects containing deeply nested objects as "detail"
|
||||
* Fixed support for relative paths in RotatingFileHandler
|
||||
|
||||
### 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.26.1 (2021-05-28)
|
||||
|
||||
* Fixed PHP 8.1 deprecation warning
|
||||
|
||||
### 1.26.0 (2020-12-14)
|
||||
|
||||
* Added $dateFormat and $removeUsedContextFields arguments to PsrLogMessageProcessor (backport from 2.x)
|
||||
|
||||
### 1.25.5 (2020-07-23)
|
||||
|
||||
* Fixed array access on null in RavenHandler
|
||||
* Fixed unique_id in WebProcessor not being disableable
|
||||
|
||||
### 1.25.4 (2020-05-22)
|
||||
|
||||
* Fixed GitProcessor type error when there is no git repo present
|
||||
* Fixed normalization of SoapFault objects containing deeply nested objects as "detail"
|
||||
* Fixed support for relative paths in RotatingFileHandler
|
||||
|
||||
### 1.25.3 (2019-12-20)
|
||||
|
||||
* 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
|
||||
|
||||
### 1.25.2 (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 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
|
||||
|
||||
### 1.25.1 (2019-09-06)
|
||||
|
||||
* Fixed forward-compatible interfaces to be compatible with Monolog 1.x too.
|
||||
|
||||
### 1.25.0 (2019-09-06)
|
||||
|
||||
* Deprecated SlackbotHandler, use SlackWebhookHandler or SlackHandler instead
|
||||
* Deprecated RavenHandler, use sentry/sentry 2.x and their Sentry\Monolog\Handler instead
|
||||
* Deprecated HipChatHandler, migrate to Slack and use SlackWebhookHandler or SlackHandler instead
|
||||
* Added forward-compatible interfaces and traits FormattableHandlerInterface, FormattableHandlerTrait, ProcessableHandlerInterface, ProcessableHandlerTrait. If you use modern PHP and want to make code compatible with Monolog 1 and 2 this can help. You will have to require at least Monolog 1.25 though.
|
||||
* Added support for RFC3164 (outdated BSD syslog protocol) to SyslogUdpHandler
|
||||
* Fixed issue in GroupHandler and WhatFailureGroupHandler where setting multiple processors would duplicate records
|
||||
* Fixed issue in SignalHandler restarting syscalls functionality
|
||||
* Fixed normalizers handling of exception backtraces to avoid serializing arguments in some cases
|
||||
* Fixed ZendMonitorHandler to work with the latest Zend Server versions
|
||||
* Fixed ChromePHPHandler to avoid sending more data than latest Chrome versions allow in headers (4KB down from 256KB).
|
||||
|
||||
### 1.24.0 (2018-11-05)
|
||||
|
||||
* BC Notice: If you are extending any of the Monolog's Formatters' `normalize` method, make sure you add the new `$depth = 0` argument to your function signature to avoid strict PHP warnings.
|
||||
* Added a `ResettableInterface` in order to reset/reset/clear/flush handlers and processors
|
||||
* Added a `ProcessorInterface` as an optional way to label a class as being a processor (mostly useful for autowiring dependency containers)
|
||||
* 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 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
|
||||
* Added SocketHandler::setChunkSize to override the default chunk size in case you must send large log lines to rsyslog for example
|
||||
* Added ability to extend/override BrowserConsoleHandler
|
||||
* Added SlackWebhookHandler::getWebhookUrl and SlackHandler::getToken to enable class extensibility
|
||||
* Added SwiftMailerHandler::getSubjectFormatter to enable class extensibility
|
||||
* Dropped official support for HHVM in test builds
|
||||
* Fixed normalization of exception traces when call_user_func is used to avoid serializing objects and the data they contain
|
||||
* Fixed naming of fields in Slack handler, all field names are now capitalized in all cases
|
||||
* Fixed HipChatHandler bug where slack dropped messages randomly
|
||||
* Fixed normalization of objects in Slack handlers
|
||||
* Fixed support for PHP7's Throwable in NewRelicHandler
|
||||
* Fixed race bug when StreamHandler sometimes incorrectly reported it failed to create a directory
|
||||
* Fixed table row styling issues in HtmlFormatter
|
||||
* Fixed RavenHandler dropping the message when logging exception
|
||||
* Fixed WhatFailureGroupHandler skipping processors when using handleBatch
|
||||
and implement it where possible
|
||||
* Fixed display of anonymous class names
|
||||
|
||||
### 1.23.0 (2017-06-19)
|
||||
|
||||
* Improved SyslogUdpHandler's support for RFC5424 and added optional `$ident` argument
|
||||
* Fixed GelfHandler truncation to be per field and not per message
|
||||
* Fixed compatibility issue with PHP <5.3.6
|
||||
* Fixed support for headless Chrome in ChromePHPHandler
|
||||
* Fixed support for latest Aws SDK in DynamoDbHandler
|
||||
* Fixed support for SwiftMailer 6.0+ in SwiftMailerHandler
|
||||
|
||||
### 1.22.1 (2017-03-13)
|
||||
|
||||
* Fixed lots of minor issues in the new Slack integrations
|
||||
* Fixed support for allowInlineLineBreaks in LineFormatter when formatting exception backtraces
|
||||
|
||||
### 1.22.0 (2016-11-26)
|
||||
|
||||
* 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 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
|
||||
* Fixed a few PHP 7.0 and 7.1 compatibility issues
|
||||
|
||||
### 1.21.0 (2016-07-29)
|
||||
|
||||
* 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 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
|
||||
|
||||
### 1.20.0 (2016-07-02)
|
||||
|
||||
* Added FingersCrossedHandler::activate() to manually trigger the handler regardless of the activation policy
|
||||
* Added StreamHandler::getUrl to retrieve the stream's URL
|
||||
* Added ability to override addRow/addTitle in HtmlFormatter
|
||||
* Added the $context to context information when the ErrorHandler handles a regular php error
|
||||
* Deprecated RotatingFileHandler::setFilenameFormat to only support 3 formats: Y, Y-m and Y-m-d
|
||||
* Fixed WhatFailureGroupHandler to work with PHP7 throwables
|
||||
* Fixed a few minor bugs
|
||||
|
||||
### 1.19.0 (2016-04-12)
|
||||
|
||||
* Break: StreamHandler will not close streams automatically that it does not own. If you pass in a stream (not a path/url), then it will not close it for you. You can retrieve those using getStream() if needed
|
||||
* Added DeduplicationHandler to remove duplicate records from notifications across multiple requests, useful for email or other notifications on errors
|
||||
* Added ability to use `%message%` and other LineFormatter replacements in the subject line of emails sent with NativeMailHandler and SwiftMailerHandler
|
||||
* Fixed HipChatHandler handling of long messages
|
||||
|
||||
### 1.18.2 (2016-04-02)
|
||||
|
||||
* Fixed ElasticaFormatter to use more precise dates
|
||||
* Fixed GelfMessageFormatter sending too long messages
|
||||
|
||||
### 1.18.1 (2016-03-13)
|
||||
|
||||
* Fixed SlackHandler bug where slack dropped messages randomly
|
||||
* Fixed RedisHandler issue when using with the PHPRedis extension
|
||||
* Fixed AmqpHandler content-type being incorrectly set when using with the AMQP extension
|
||||
* Fixed BrowserConsoleHandler regression
|
||||
|
||||
### 1.18.0 (2016-03-01)
|
||||
|
||||
* Added optional reduction of timestamp precision via `Logger->useMicrosecondTimestamps(false)`, disabling it gets you a bit of performance boost but reduces the precision to the second instead of microsecond
|
||||
* Added possibility to skip some extra stack frames in IntrospectionProcessor if you have some library wrapping Monolog that is always adding frames
|
||||
* Added `Logger->withName` to clone a logger (keeping all handlers) with a new name
|
||||
* Added FluentdFormatter for the Fluentd unix socket protocol
|
||||
* Added HandlerWrapper base class to ease the creation of handler wrappers, just extend it and override as needed
|
||||
* Added support for replacing context sub-keys using `%context.*%` in LineFormatter
|
||||
* Added support for `payload` context value in RollbarHandler
|
||||
* Added setRelease to RavenHandler to describe the application version, sent with every log
|
||||
* Added support for `fingerprint` context value in RavenHandler
|
||||
* Fixed JSON encoding errors that would gobble up the whole log record, we now handle those more gracefully by dropping chars as needed
|
||||
* Fixed write timeouts in SocketHandler and derivatives, set to 10sec by default, lower it with `setWritingTimeout()`
|
||||
* Fixed PHP7 compatibility with regard to Exception/Throwable handling in a few places
|
||||
|
||||
### 1.17.2 (2015-10-14)
|
||||
|
||||
* Fixed ErrorHandler compatibility with non-Monolog PSR-3 loggers
|
||||
* Fixed SlackHandler handling to use slack functionalities better
|
||||
* Fixed SwiftMailerHandler bug when sending multiple emails they all had the same id
|
||||
* Fixed 5.3 compatibility regression
|
||||
|
||||
### 1.17.1 (2015-08-31)
|
||||
|
||||
* Fixed RollbarHandler triggering PHP notices
|
||||
|
||||
### 1.17.0 (2015-08-30)
|
||||
|
||||
* Added support for `checksum` and `release` context/extra values in RavenHandler
|
||||
* Added better support for exceptions in RollbarHandler
|
||||
* Added UidProcessor::getUid
|
||||
* Added support for showing the resource type in NormalizedFormatter
|
||||
* Fixed IntrospectionProcessor triggering PHP notices
|
||||
|
||||
### 1.16.0 (2015-08-09)
|
||||
|
||||
* Added IFTTTHandler to notify ifttt.com triggers
|
||||
* Added Logger::setHandlers() to allow setting/replacing all handlers
|
||||
* Added $capSize in RedisHandler to cap the log size
|
||||
* Fixed StreamHandler creation of directory to only trigger when the first log write happens
|
||||
* Fixed bug in the handling of curl failures
|
||||
* Fixed duplicate logging of fatal errors when both error and fatal error handlers are registered in monolog's ErrorHandler
|
||||
* Fixed missing fatal errors records with handlers that need to be closed to flush log records
|
||||
* Fixed TagProcessor::addTags support for associative arrays
|
||||
|
||||
### 1.15.0 (2015-07-12)
|
||||
|
||||
* Added addTags and setTags methods to change a TagProcessor
|
||||
* Added automatic creation of directories if they are missing for a StreamHandler to open a log file
|
||||
* Added retry functionality to Loggly, Cube and Mandrill handlers so they retry up to 5 times in case of network failure
|
||||
* Fixed process exit code being incorrectly reset to 0 if ErrorHandler::registerExceptionHandler was used
|
||||
* Fixed HTML/JS escaping in BrowserConsoleHandler
|
||||
* Fixed JSON encoding errors being silently suppressed (PHP 5.5+ only)
|
||||
|
||||
### 1.14.0 (2015-06-19)
|
||||
|
||||
* Added PHPConsoleHandler to send record to Chrome's PHP Console extension and library
|
||||
* Added support for objects implementing __toString in the NormalizerFormatter
|
||||
* Added support for HipChat's v2 API in HipChatHandler
|
||||
* Added Logger::setTimezone() to initialize the timezone monolog should use in case date.timezone isn't correct for your app
|
||||
* Added an option to send formatted message instead of the raw record on PushoverHandler via ->useFormattedMessage(true)
|
||||
* Fixed curl errors being silently suppressed
|
||||
|
||||
### 1.13.1 (2015-03-09)
|
||||
|
||||
* Fixed regression in HipChat requiring a new token to be created
|
||||
|
||||
### 1.13.0 (2015-03-05)
|
||||
|
||||
* Added Registry::hasLogger to check for the presence of a logger instance
|
||||
* Added context.user support to RavenHandler
|
||||
* Added HipChat API v2 support in the HipChatHandler
|
||||
* Added NativeMailerHandler::addParameter to pass params to the mail() process
|
||||
* Added context data to SlackHandler when $includeContextAndExtra is true
|
||||
* Added ability to customize the Swift_Message per-email in SwiftMailerHandler
|
||||
* Fixed SwiftMailerHandler to lazily create message instances if a callback is provided
|
||||
* Fixed serialization of INF and NaN values in Normalizer and LineFormatter
|
||||
|
||||
### 1.12.0 (2014-12-29)
|
||||
|
||||
* Break: HandlerInterface::isHandling now receives a partial record containing only a level key. This was always the intent and does not break any Monolog handler but is strictly speaking a BC break and you should check if you relied on any other field in your own handlers.
|
||||
* Added PsrHandler to forward records to another PSR-3 logger
|
||||
* Added SamplingHandler to wrap around a handler and include only every Nth record
|
||||
* Added MongoDBFormatter to support better storage with MongoDBHandler (it must be enabled manually for now)
|
||||
* Added exception codes in the output of most formatters
|
||||
* Added LineFormatter::includeStacktraces to enable exception stack traces in logs (uses more than one line)
|
||||
* 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 some non-standard behaviors in SyslogUdpHandler
|
||||
|
||||
### 1.11.0 (2014-09-30)
|
||||
|
||||
* Break: The NewRelicHandler extra and context data are now prefixed with extra_ and context_ to avoid clashes. Watch out if you have scripts reading those from the API and rely on names
|
||||
* Added WhatFailureGroupHandler to suppress any exception coming from the wrapped handlers and avoid chain failures if a logging service fails
|
||||
* Added MandrillHandler to send emails via the Mandrillapp.com API
|
||||
* Added SlackHandler to log records to a Slack.com account
|
||||
* Added FleepHookHandler to log records to a Fleep.io account
|
||||
* Added LogglyHandler::addTag to allow adding tags to an existing handler
|
||||
* Added $ignoreEmptyContextAndExtra to LineFormatter to avoid empty [] at the end
|
||||
* Added $useLocking to StreamHandler and RotatingFileHandler to enable flock() while writing
|
||||
* Added support for PhpAmqpLib in the AmqpHandler
|
||||
* Added FingersCrossedHandler::clear and BufferHandler::clear to reset them between batches in long running jobs
|
||||
* Added support for adding extra fields from $_SERVER in the WebProcessor
|
||||
* Fixed support for non-string values in PrsLogMessageProcessor
|
||||
* Fixed SwiftMailer messages being sent with the wrong date in long running scripts
|
||||
* Fixed minor PHP 5.6 compatibility issues
|
||||
* Fixed BufferHandler::close being called twice
|
||||
|
||||
### 1.10.0 (2014-06-04)
|
||||
|
||||
* Added Logger::getHandlers() and Logger::getProcessors() methods
|
||||
* Added $passthruLevel argument to FingersCrossedHandler to let it always pass some records through even if the trigger level is not reached
|
||||
* Added support for extra data in NewRelicHandler
|
||||
* Added $expandNewlines flag to the ErrorLogHandler to create multiple log entries when a message has multiple lines
|
||||
|
||||
### 1.9.1 (2014-04-24)
|
||||
|
||||
* Fixed regression in RotatingFileHandler file permissions
|
||||
* Fixed initialization of the BufferHandler to make sure it gets flushed after receiving records
|
||||
* Fixed ChromePHPHandler and FirePHPHandler's activation strategies to be more conservative
|
||||
|
||||
### 1.9.0 (2014-04-20)
|
||||
|
||||
* Added LogEntriesHandler to send logs to a LogEntries account
|
||||
* Added $filePermissions to tweak file mode on StreamHandler and RotatingFileHandler
|
||||
* Added $useFormatting flag to MemoryProcessor to make it send raw data in bytes
|
||||
* Added support for table formatting in FirePHPHandler via the table context key
|
||||
* Added a TagProcessor to add tags to records, and support for tags in RavenHandler
|
||||
* Added $appendNewline flag to the JsonFormatter to enable using it when logging to files
|
||||
* Added sound support to the PushoverHandler
|
||||
* Fixed multi-threading support in StreamHandler
|
||||
* Fixed empty headers issue when ChromePHPHandler received no records
|
||||
* Fixed default format of the ErrorLogHandler
|
||||
|
||||
### 1.8.0 (2014-03-23)
|
||||
|
||||
* Break: the LineFormatter now strips newlines by default because this was a bug, set $allowInlineLineBreaks to true if you need them
|
||||
* Added BrowserConsoleHandler to send logs to any browser's console via console.log() injection in the output
|
||||
* Added FilterHandler to filter records and only allow those of a given list of levels through to the wrapped handler
|
||||
* Added FlowdockHandler to send logs to a Flowdock account
|
||||
* Added RollbarHandler to send logs to a Rollbar account
|
||||
* Added HtmlFormatter to send prettier log emails with colors for each log level
|
||||
* Added GitProcessor to add the current branch/commit to extra record data
|
||||
* Added a Monolog\Registry class to allow easier global access to pre-configured loggers
|
||||
* Added support for the new official graylog2/gelf-php lib for GelfHandler, upgrade if you can by replacing the mlehner/gelf-php requirement
|
||||
* Added support for HHVM
|
||||
* Added support for Loggly batch uploads
|
||||
* Added support for tweaking the content type and encoding in NativeMailerHandler
|
||||
* Added $skipClassesPartials to tweak the ignored classes in the IntrospectionProcessor
|
||||
* Fixed batch request support in GelfHandler
|
||||
|
||||
### 1.7.0 (2013-11-14)
|
||||
|
||||
* Added ElasticSearchHandler to send logs to an Elastic Search server
|
||||
* Added DynamoDbHandler and ScalarFormatter to send logs to Amazon's Dynamo DB
|
||||
* Added SyslogUdpHandler to send logs to a remote syslogd server
|
||||
* Added LogglyHandler to send logs to a Loggly account
|
||||
* Added $level to IntrospectionProcessor so it only adds backtraces when needed
|
||||
* Added $version to LogstashFormatter to allow using the new v1 Logstash format
|
||||
* Added $appName to NewRelicHandler
|
||||
* Added configuration of Pushover notification retries/expiry
|
||||
* Added $maxColumnWidth to NativeMailerHandler to change the 70 chars default
|
||||
* Added chainability to most setters for all handlers
|
||||
* Fixed RavenHandler batch processing so it takes the message from the record with highest priority
|
||||
* Fixed HipChatHandler batch processing so it sends all messages at once
|
||||
* Fixed issues with eAccelerator
|
||||
* Fixed and improved many small things
|
||||
|
||||
### 1.6.0 (2013-07-29)
|
||||
|
||||
* Added HipChatHandler to send logs to a HipChat chat room
|
||||
* Added ErrorLogHandler to send logs to PHP's error_log function
|
||||
* Added NewRelicHandler to send logs to NewRelic's service
|
||||
* Added Monolog\ErrorHandler helper class to register a Logger as exception/error/fatal handler
|
||||
* Added ChannelLevelActivationStrategy for the FingersCrossedHandler to customize levels by channel
|
||||
* Added stack traces output when normalizing exceptions (json output & co)
|
||||
* Added Monolog\Logger::API constant (currently 1)
|
||||
* Added support for ChromePHP's v4.0 extension
|
||||
* Added support for message priorities in PushoverHandler, see $highPriorityLevel and $emergencyLevel
|
||||
* Added support for sending messages to multiple users at once with the PushoverHandler
|
||||
* Fixed RavenHandler's support for batch sending of messages (when behind a Buffer or FingersCrossedHandler)
|
||||
* Fixed normalization of Traversables with very large data sets, only the first 1000 items are shown now
|
||||
* Fixed issue in RotatingFileHandler when an open_basedir restriction is active
|
||||
* Fixed minor issues in RavenHandler and bumped the API to Raven 0.5.0
|
||||
* Fixed SyslogHandler issue when many were used concurrently with different facilities
|
||||
|
||||
### 1.5.0 (2013-04-23)
|
||||
|
||||
* Added ProcessIdProcessor to inject the PID in log records
|
||||
* Added UidProcessor to inject a unique identifier to all log records of one request/run
|
||||
* Added support for previous exceptions in the LineFormatter exception serialization
|
||||
* Added Monolog\Logger::getLevels() to get all available levels
|
||||
* Fixed ChromePHPHandler so it avoids sending headers larger than Chrome can handle
|
||||
|
||||
### 1.4.1 (2013-04-01)
|
||||
|
||||
* Fixed exception formatting in the LineFormatter to be more minimalistic
|
||||
* Fixed RavenHandler's handling of context/extra data, requires Raven client >0.1.0
|
||||
* Fixed log rotation in RotatingFileHandler to work with long running scripts spanning multiple days
|
||||
* Fixed WebProcessor array access so it checks for data presence
|
||||
* Fixed Buffer, Group and FingersCrossed handlers to make use of their processors
|
||||
|
||||
### 1.4.0 (2013-02-13)
|
||||
|
||||
* Added RedisHandler to log to Redis via the Predis library or the phpredis extension
|
||||
* Added ZendMonitorHandler to log to the Zend Server monitor
|
||||
* Added the possibility to pass arrays of handlers and processors directly in the Logger constructor
|
||||
* Added `$useSSL` option to the PushoverHandler which is enabled by default
|
||||
* Fixed ChromePHPHandler and FirePHPHandler issue when multiple instances are used simultaneously
|
||||
* Fixed header injection capability in the NativeMailHandler
|
||||
|
||||
### 1.3.1 (2013-01-11)
|
||||
|
||||
* Fixed LogstashFormatter to be usable with stream handlers
|
||||
* Fixed GelfMessageFormatter levels on Windows
|
||||
|
||||
### 1.3.0 (2013-01-08)
|
||||
|
||||
* Added PSR-3 compliance, the `Monolog\Logger` class is now an instance of `Psr\Log\LoggerInterface`
|
||||
* Added PsrLogMessageProcessor that you can selectively enable for full PSR-3 compliance
|
||||
* Added LogstashFormatter (combine with SocketHandler or StreamHandler to send logs to Logstash)
|
||||
* Added PushoverHandler to send mobile notifications
|
||||
* Added CouchDBHandler and DoctrineCouchDBHandler
|
||||
* Added RavenHandler to send data to Sentry servers
|
||||
* Added support for the new MongoClient class in MongoDBHandler
|
||||
* Added microsecond precision to log records' timestamps
|
||||
* Added `$flushOnOverflow` param to BufferHandler to flush by batches instead of losing
|
||||
the oldest entries
|
||||
* Fixed normalization of objects with cyclic references
|
||||
|
||||
### 1.2.1 (2012-08-29)
|
||||
|
||||
* Added new $logopts arg to SyslogHandler to provide custom openlog options
|
||||
* Fixed fatal error in SyslogHandler
|
||||
|
||||
### 1.2.0 (2012-08-18)
|
||||
|
||||
* Added AmqpHandler (for use with AMQP servers)
|
||||
* Added CubeHandler
|
||||
* Added NativeMailerHandler::addHeader() to send custom headers in mails
|
||||
* Added the possibility to specify more than one recipient in NativeMailerHandler
|
||||
* Added the possibility to specify float timeouts in SocketHandler
|
||||
* Added NOTICE and EMERGENCY levels to conform with RFC 5424
|
||||
* Fixed the log records to use the php default timezone instead of UTC
|
||||
* Fixed BufferHandler not being flushed properly on PHP fatal errors
|
||||
* Fixed normalization of exotic resource types
|
||||
* Fixed the default format of the SyslogHandler to avoid duplicating datetimes in syslog
|
||||
|
||||
### 1.1.0 (2012-04-23)
|
||||
|
||||
* Added Monolog\Logger::isHandling() to check if a handler will
|
||||
handle the given log level
|
||||
* Added ChromePHPHandler
|
||||
* Added MongoDBHandler
|
||||
* Added GelfHandler (for use with Graylog2 servers)
|
||||
* Added SocketHandler (for use with syslog-ng for example)
|
||||
* Added NormalizerFormatter
|
||||
* Added the possibility to change the activation strategy of the FingersCrossedHandler
|
||||
* Added possibility to show microseconds in logs
|
||||
* Added `server` and `referer` to WebProcessor output
|
||||
|
||||
### 1.0.2 (2011-10-24)
|
||||
|
||||
* Fixed bug in IE with large response headers and FirePHPHandler
|
||||
|
||||
### 1.0.1 (2011-08-25)
|
||||
|
||||
* Added MemoryPeakUsageProcessor and MemoryUsageProcessor
|
||||
* Added Monolog\Logger::getName() to get a logger's channel name
|
||||
|
||||
### 1.0.0 (2011-07-06)
|
||||
|
||||
* Added IntrospectionProcessor to get info from where the logger was called
|
||||
* Fixed WebProcessor in CLI
|
||||
|
||||
### 1.0.0-RC1 (2011-07-01)
|
||||
|
||||
* Initial release
|
||||
19
vendor/Gcp/monolog/monolog/LICENSE
vendored
Normal file
19
vendor/Gcp/monolog/monolog/LICENSE
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
Copyright (c) 2011-2020 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
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is furnished
|
||||
to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
72
vendor/Gcp/monolog/monolog/UPGRADE.md
vendored
Normal file
72
vendor/Gcp/monolog/monolog/UPGRADE.md
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
### 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.
|
||||
42
vendor/Gcp/monolog/monolog/src/Monolog/Attribute/AsMonologProcessor.php
vendored
Normal file
42
vendor/Gcp/monolog/monolog/src/Monolog/Attribute/AsMonologProcessor.php
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Attribute;
|
||||
|
||||
/**
|
||||
* A reusable attribute to help configure a class or a method as a processor.
|
||||
*
|
||||
* Using it offers no guarantee: it needs to be leveraged by a Monolog third-party consumer.
|
||||
*
|
||||
* Using it with the Monolog library only has no effect at all: processors should still be turned into a callable if
|
||||
* needed and manually pushed to the loggers and to the processable handlers.
|
||||
*/
|
||||
#[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)]
|
||||
class AsMonologProcessor
|
||||
{
|
||||
/** @var string|null */
|
||||
public $channel = null;
|
||||
/** @var string|null */
|
||||
public $handler = null;
|
||||
/** @var string|null */
|
||||
public $method = null;
|
||||
/**
|
||||
* @param string|null $channel The logging channel the processor should be pushed to.
|
||||
* @param string|null $handler The handler the processor should be pushed to.
|
||||
* @param string|null $method The method that processes the records (if the attribute is used at the class level).
|
||||
*/
|
||||
public function __construct(?string $channel = null, ?string $handler = null, ?string $method = null)
|
||||
{
|
||||
$this->channel = $channel;
|
||||
$this->handler = $handler;
|
||||
$this->method = $method;
|
||||
}
|
||||
}
|
||||
45
vendor/Gcp/monolog/monolog/src/Monolog/DateTimeImmutable.php
vendored
Normal file
45
vendor/Gcp/monolog/monolog/src/Monolog/DateTimeImmutable.php
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\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;
|
||||
// if you like to use a custom time to pass to Logger::addRecord directly,
|
||||
// call modify() or setTimestamp() on this instance to change the date after creating it
|
||||
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();
|
||||
}
|
||||
}
|
||||
249
vendor/Gcp/monolog/monolog/src/Monolog/ErrorHandler.php
vendored
Normal file
249
vendor/Gcp/monolog/monolog/src/Monolog/ErrorHandler.php
vendored
Normal file
@@ -0,0 +1,249 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LoggerInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Monolog error handler
|
||||
*
|
||||
* A facility to enable logging of runtime errors, exceptions and fatal errors.
|
||||
*
|
||||
* Quick setup: <code>ErrorHandler::register($logger);</code>
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*/
|
||||
class ErrorHandler
|
||||
{
|
||||
/** @var LoggerInterface */
|
||||
private $logger;
|
||||
/** @var ?callable */
|
||||
private $previousExceptionHandler = null;
|
||||
/** @var array<class-string, LogLevel::*> an array of class name to LogLevel::* constant mapping */
|
||||
private $uncaughtExceptionLevelMap = [];
|
||||
/** @var callable|true|null */
|
||||
private $previousErrorHandler = null;
|
||||
/** @var array<int, LogLevel::*> an array of E_* constant to LogLevel::* constant mapping */
|
||||
private $errorLevelMap = [];
|
||||
/** @var bool */
|
||||
private $handleOnlyReportedErrors = \true;
|
||||
/** @var bool */
|
||||
private $hasFatalErrorHandler = \false;
|
||||
/** @var LogLevel::* */
|
||||
private $fatalLevel = LogLevel::ALERT;
|
||||
/** @var ?string */
|
||||
private $reservedMemory = null;
|
||||
/** @var ?array{type: int, message: string, file: string, line: int, trace: mixed} */
|
||||
private $lastFatalData = null;
|
||||
/** @var int[] */
|
||||
private static $fatalErrors = [\E_ERROR, \E_PARSE, \E_CORE_ERROR, \E_COMPILE_ERROR, \E_USER_ERROR];
|
||||
public function __construct(LoggerInterface $logger)
|
||||
{
|
||||
$this->logger = $logger;
|
||||
}
|
||||
/**
|
||||
* Registers a new ErrorHandler for a given Logger
|
||||
*
|
||||
* By default it will handle errors, exceptions and fatal errors
|
||||
*
|
||||
* @param LoggerInterface $logger
|
||||
* @param array<int, LogLevel::*>|false $errorLevelMap an array of E_* constant to LogLevel::* constant mapping, or false to disable error handling
|
||||
* @param array<class-string, LogLevel::*>|false $exceptionLevelMap an array of class name to LogLevel::* constant mapping, or false to disable exception handling
|
||||
* @param LogLevel::*|null|false $fatalLevel a LogLevel::* constant, null to use the default LogLevel::ALERT or false to disable fatal error handling
|
||||
* @return ErrorHandler
|
||||
*/
|
||||
public static function register(LoggerInterface $logger, $errorLevelMap = [], $exceptionLevelMap = [], $fatalLevel = null) : self
|
||||
{
|
||||
/** @phpstan-ignore-next-line */
|
||||
$handler = new static($logger);
|
||||
if ($errorLevelMap !== \false) {
|
||||
$handler->registerErrorHandler($errorLevelMap);
|
||||
}
|
||||
if ($exceptionLevelMap !== \false) {
|
||||
$handler->registerExceptionHandler($exceptionLevelMap);
|
||||
}
|
||||
if ($fatalLevel !== \false) {
|
||||
$handler->registerFatalHandler($fatalLevel);
|
||||
}
|
||||
return $handler;
|
||||
}
|
||||
/**
|
||||
* @param array<class-string, LogLevel::*> $levelMap an array of class name to LogLevel::* constant mapping
|
||||
* @return $this
|
||||
*/
|
||||
public function registerExceptionHandler(array $levelMap = [], bool $callPrevious = \true) : self
|
||||
{
|
||||
$prev = \set_exception_handler(function (\Throwable $e) : void {
|
||||
$this->handleException($e);
|
||||
});
|
||||
$this->uncaughtExceptionLevelMap = $levelMap;
|
||||
foreach ($this->defaultExceptionLevelMap() as $class => $level) {
|
||||
if (!isset($this->uncaughtExceptionLevelMap[$class])) {
|
||||
$this->uncaughtExceptionLevelMap[$class] = $level;
|
||||
}
|
||||
}
|
||||
if ($callPrevious && $prev) {
|
||||
$this->previousExceptionHandler = $prev;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @param array<int, LogLevel::*> $levelMap an array of E_* constant to LogLevel::* constant mapping
|
||||
* @return $this
|
||||
*/
|
||||
public function registerErrorHandler(array $levelMap = [], bool $callPrevious = \true, int $errorTypes = -1, bool $handleOnlyReportedErrors = \true) : self
|
||||
{
|
||||
$prev = \set_error_handler([$this, 'handleError'], $errorTypes);
|
||||
$this->errorLevelMap = \array_replace($this->defaultErrorLevelMap(), $levelMap);
|
||||
if ($callPrevious) {
|
||||
$this->previousErrorHandler = $prev ?: \true;
|
||||
} else {
|
||||
$this->previousErrorHandler = null;
|
||||
}
|
||||
$this->handleOnlyReportedErrors = $handleOnlyReportedErrors;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @param LogLevel::*|null $level a LogLevel::* constant, null to use the default LogLevel::ALERT
|
||||
* @param int $reservedMemorySize Amount of KBs to reserve in memory so that it can be freed when handling fatal errors giving Monolog some room in memory to get its job done
|
||||
*/
|
||||
public function registerFatalHandler($level = null, int $reservedMemorySize = 20) : self
|
||||
{
|
||||
\register_shutdown_function([$this, 'handleFatalError']);
|
||||
$this->reservedMemory = \str_repeat(' ', 1024 * $reservedMemorySize);
|
||||
$this->fatalLevel = null === $level ? LogLevel::ALERT : $level;
|
||||
$this->hasFatalErrorHandler = \true;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @return array<class-string, LogLevel::*>
|
||||
*/
|
||||
protected function defaultExceptionLevelMap() : array
|
||||
{
|
||||
return ['ParseError' => LogLevel::CRITICAL, 'Throwable' => LogLevel::ERROR];
|
||||
}
|
||||
/**
|
||||
* @return array<int, LogLevel::*>
|
||||
*/
|
||||
protected function defaultErrorLevelMap() : array
|
||||
{
|
||||
return [\E_ERROR => LogLevel::CRITICAL, \E_WARNING => LogLevel::WARNING, \E_PARSE => LogLevel::ALERT, \E_NOTICE => LogLevel::NOTICE, \E_CORE_ERROR => LogLevel::CRITICAL, \E_CORE_WARNING => LogLevel::WARNING, \E_COMPILE_ERROR => LogLevel::ALERT, \E_COMPILE_WARNING => LogLevel::WARNING, \E_USER_ERROR => LogLevel::ERROR, \E_USER_WARNING => LogLevel::WARNING, \E_USER_NOTICE => LogLevel::NOTICE, \E_STRICT => LogLevel::NOTICE, \E_RECOVERABLE_ERROR => LogLevel::ERROR, \E_DEPRECATED => LogLevel::NOTICE, \E_USER_DEPRECATED => LogLevel::NOTICE];
|
||||
}
|
||||
/**
|
||||
* @phpstan-return never
|
||||
*/
|
||||
private function handleException(\Throwable $e) : void
|
||||
{
|
||||
$level = LogLevel::ERROR;
|
||||
foreach ($this->uncaughtExceptionLevelMap as $class => $candidate) {
|
||||
if ($e instanceof $class) {
|
||||
$level = $candidate;
|
||||
break;
|
||||
}
|
||||
}
|
||||
$this->logger->log($level, \sprintf('Uncaught Exception %s: "%s" at %s line %s', Utils::getClass($e), $e->getMessage(), $e->getFile(), $e->getLine()), ['exception' => $e]);
|
||||
if ($this->previousExceptionHandler) {
|
||||
($this->previousExceptionHandler)($e);
|
||||
}
|
||||
if (!\headers_sent() && \in_array(\strtolower((string) \ini_get('display_errors')), ['0', '', 'false', 'off', 'none', 'no'], \true)) {
|
||||
\http_response_code(500);
|
||||
}
|
||||
exit(255);
|
||||
}
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param mixed[] $context
|
||||
*/
|
||||
public function handleError(int $code, string $message, string $file = '', int $line = 0, ?array $context = []) : bool
|
||||
{
|
||||
if ($this->handleOnlyReportedErrors && !(\error_reporting() & $code)) {
|
||||
return \false;
|
||||
}
|
||||
// fatal error codes are ignored if a fatal error handler is present as well to avoid duplicate log entries
|
||||
if (!$this->hasFatalErrorHandler || !\in_array($code, self::$fatalErrors, \true)) {
|
||||
$level = $this->errorLevelMap[$code] ?? LogLevel::CRITICAL;
|
||||
$this->logger->log($level, self::codeToString($code) . ': ' . $message, ['code' => $code, 'message' => $message, 'file' => $file, 'line' => $line]);
|
||||
} else {
|
||||
$trace = \debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS);
|
||||
\array_shift($trace);
|
||||
// Exclude handleError from trace
|
||||
$this->lastFatalData = ['type' => $code, 'message' => $message, 'file' => $file, 'line' => $line, 'trace' => $trace];
|
||||
}
|
||||
if ($this->previousErrorHandler === \true) {
|
||||
return \false;
|
||||
} elseif ($this->previousErrorHandler) {
|
||||
return (bool) ($this->previousErrorHandler)($code, $message, $file, $line, $context);
|
||||
}
|
||||
return \true;
|
||||
}
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
public function handleFatalError() : void
|
||||
{
|
||||
$this->reservedMemory = '';
|
||||
if (\is_array($this->lastFatalData)) {
|
||||
$lastError = $this->lastFatalData;
|
||||
} else {
|
||||
$lastError = \error_get_last();
|
||||
}
|
||||
if ($lastError && \in_array($lastError['type'], self::$fatalErrors, \true)) {
|
||||
$trace = $lastError['trace'] ?? null;
|
||||
$this->logger->log($this->fatalLevel, 'Fatal Error (' . self::codeToString($lastError['type']) . '): ' . $lastError['message'], ['code' => $lastError['type'], 'message' => $lastError['message'], 'file' => $lastError['file'], 'line' => $lastError['line'], 'trace' => $trace]);
|
||||
if ($this->logger instanceof Logger) {
|
||||
foreach ($this->logger->getHandlers() as $handler) {
|
||||
$handler->close();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param int $code
|
||||
*/
|
||||
private static function codeToString($code) : string
|
||||
{
|
||||
switch ($code) {
|
||||
case \E_ERROR:
|
||||
return 'E_ERROR';
|
||||
case \E_WARNING:
|
||||
return 'E_WARNING';
|
||||
case \E_PARSE:
|
||||
return 'E_PARSE';
|
||||
case \E_NOTICE:
|
||||
return 'E_NOTICE';
|
||||
case \E_CORE_ERROR:
|
||||
return 'E_CORE_ERROR';
|
||||
case \E_CORE_WARNING:
|
||||
return 'E_CORE_WARNING';
|
||||
case \E_COMPILE_ERROR:
|
||||
return 'E_COMPILE_ERROR';
|
||||
case \E_COMPILE_WARNING:
|
||||
return 'E_COMPILE_WARNING';
|
||||
case \E_USER_ERROR:
|
||||
return 'E_USER_ERROR';
|
||||
case \E_USER_WARNING:
|
||||
return 'E_USER_WARNING';
|
||||
case \E_USER_NOTICE:
|
||||
return 'E_USER_NOTICE';
|
||||
case \E_STRICT:
|
||||
return 'E_STRICT';
|
||||
case \E_RECOVERABLE_ERROR:
|
||||
return 'E_RECOVERABLE_ERROR';
|
||||
case \E_DEPRECATED:
|
||||
return 'E_DEPRECATED';
|
||||
case \E_USER_DEPRECATED:
|
||||
return 'E_USER_DEPRECATED';
|
||||
}
|
||||
return 'Unknown PHP error';
|
||||
}
|
||||
}
|
||||
62
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ChromePHPFormatter.php
vendored
Normal file
62
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ChromePHPFormatter.php
vendored
Normal file
@@ -0,0 +1,62 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Formats a log message according to the ChromePHP array format
|
||||
*
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
*/
|
||||
class ChromePHPFormatter implements FormatterInterface
|
||||
{
|
||||
/**
|
||||
* Translates Monolog log levels to Wildfire levels.
|
||||
*
|
||||
* @var array<int, 'log'|'info'|'warn'|'error'>
|
||||
*/
|
||||
private $logLevels = [Logger::DEBUG => 'log', Logger::INFO => 'info', Logger::NOTICE => 'info', Logger::WARNING => 'warn', Logger::ERROR => 'error', Logger::CRITICAL => 'error', Logger::ALERT => 'error', Logger::EMERGENCY => 'error'];
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function format(array $record)
|
||||
{
|
||||
// Retrieve the line and file if set and remove them from the formatted extra
|
||||
$backtrace = 'unknown';
|
||||
if (isset($record['extra']['file'], $record['extra']['line'])) {
|
||||
$backtrace = $record['extra']['file'] . ' : ' . $record['extra']['line'];
|
||||
unset($record['extra']['file'], $record['extra']['line']);
|
||||
}
|
||||
$message = ['message' => $record['message']];
|
||||
if ($record['context']) {
|
||||
$message['context'] = $record['context'];
|
||||
}
|
||||
if ($record['extra']) {
|
||||
$message['extra'] = $record['extra'];
|
||||
}
|
||||
if (\count($message) === 1) {
|
||||
$message = \reset($message);
|
||||
}
|
||||
return [$record['channel'], $message, $backtrace, $this->logLevels[$record['level']]];
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function formatBatch(array $records)
|
||||
{
|
||||
$formatted = [];
|
||||
foreach ($records as $record) {
|
||||
$formatted[] = $this->format($record);
|
||||
}
|
||||
return $formatted;
|
||||
}
|
||||
}
|
||||
79
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ElasticaFormatter.php
vendored
Normal file
79
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ElasticaFormatter.php
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elastica\Document;
|
||||
/**
|
||||
* Format a log message into an Elastica Document
|
||||
*
|
||||
* @author Jelle Vink <jelle.vink@gmail.com>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class ElasticaFormatter extends NormalizerFormatter
|
||||
{
|
||||
/**
|
||||
* @var string Elastic search index name
|
||||
*/
|
||||
protected $index;
|
||||
/**
|
||||
* @var ?string Elastic search document type
|
||||
*/
|
||||
protected $type;
|
||||
/**
|
||||
* @param string $index Elastic Search index name
|
||||
* @param ?string $type Elastic Search document type, deprecated as of Elastica 7
|
||||
*/
|
||||
public function __construct(string $index, ?string $type)
|
||||
{
|
||||
// elasticsearch requires a ISO 8601 format date with optional millisecond precision.
|
||||
parent::__construct('Y-m-d\\TH:i:s.uP');
|
||||
$this->index = $index;
|
||||
$this->type = $type;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function format(array $record)
|
||||
{
|
||||
$record = parent::format($record);
|
||||
return $this->getDocument($record);
|
||||
}
|
||||
public function getIndex() : string
|
||||
{
|
||||
return $this->index;
|
||||
}
|
||||
/**
|
||||
* @deprecated since Elastica 7 type has no effect
|
||||
*/
|
||||
public function getType() : string
|
||||
{
|
||||
/** @phpstan-ignore-next-line */
|
||||
return $this->type;
|
||||
}
|
||||
/**
|
||||
* Convert a log message into an Elastica Document
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
protected function getDocument(array $record) : Document
|
||||
{
|
||||
$document = new Document();
|
||||
$document->setData($record);
|
||||
if (\method_exists($document, 'setType')) {
|
||||
/** @phpstan-ignore-next-line */
|
||||
$document->setType($this->type);
|
||||
}
|
||||
$document->setIndex($this->index);
|
||||
return $document;
|
||||
}
|
||||
}
|
||||
79
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ElasticsearchFormatter.php
vendored
Normal file
79
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ElasticsearchFormatter.php
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DateTimeInterface;
|
||||
/**
|
||||
* 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(DateTimeInterface::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 mixed[] $record Log message
|
||||
* @return mixed[]
|
||||
*/
|
||||
protected function getDocument(array $record) : array
|
||||
{
|
||||
$record['_index'] = $this->index;
|
||||
$record['_type'] = $this->type;
|
||||
return $record;
|
||||
}
|
||||
}
|
||||
81
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/FlowdockFormatter.php
vendored
Normal file
81
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/FlowdockFormatter.php
vendored
Normal file
@@ -0,0 +1,81 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
/**
|
||||
* formats the record to be used in the FlowdockHandler
|
||||
*
|
||||
* @author Dominik Liebler <liebler.dominik@gmail.com>
|
||||
* @deprecated Since 2.9.0 and 3.3.0, Flowdock was shutdown we will thus drop this handler in Monolog 4
|
||||
*/
|
||||
class FlowdockFormatter implements FormatterInterface
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $source;
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $sourceEmail;
|
||||
public function __construct(string $source, string $sourceEmail)
|
||||
{
|
||||
$this->source = $source;
|
||||
$this->sourceEmail = $sourceEmail;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function format(array $record) : array
|
||||
{
|
||||
$tags = ['#logs', '#' . \strtolower($record['level_name']), '#' . $record['channel']];
|
||||
foreach ($record['extra'] as $value) {
|
||||
$tags[] = '#' . $value;
|
||||
}
|
||||
$subject = \sprintf('in %s: %s - %s', $this->source, $record['level_name'], $this->getShortMessage($record['message']));
|
||||
$record['flowdock'] = ['source' => $this->source, 'from_address' => $this->sourceEmail, 'subject' => $subject, 'content' => $record['message'], 'tags' => $tags, 'project' => $this->source];
|
||||
return $record;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @return mixed[][]
|
||||
*/
|
||||
public function formatBatch(array $records) : array
|
||||
{
|
||||
$formatted = [];
|
||||
foreach ($records as $record) {
|
||||
$formatted[] = $this->format($record);
|
||||
}
|
||||
return $formatted;
|
||||
}
|
||||
public function getShortMessage(string $message) : string
|
||||
{
|
||||
static $hasMbString;
|
||||
if (null === $hasMbString) {
|
||||
$hasMbString = \function_exists('mb_strlen');
|
||||
}
|
||||
$maxLength = 45;
|
||||
if ($hasMbString) {
|
||||
if (\mb_strlen($message, 'UTF-8') > $maxLength) {
|
||||
$message = \mb_substr($message, 0, $maxLength - 4, 'UTF-8') . ' ...';
|
||||
}
|
||||
} else {
|
||||
if (\strlen($message) > $maxLength) {
|
||||
$message = \substr($message, 0, $maxLength - 4) . ' ...';
|
||||
}
|
||||
}
|
||||
return $message;
|
||||
}
|
||||
}
|
||||
74
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/FluentdFormatter.php
vendored
Normal file
74
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/FluentdFormatter.php
vendored
Normal file
@@ -0,0 +1,74 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Class FluentdFormatter
|
||||
*
|
||||
* Serializes a log message to Fluentd unix socket protocol
|
||||
*
|
||||
* Fluentd config:
|
||||
*
|
||||
* <source>
|
||||
* type unix
|
||||
* path /var/run/td-agent/td-agent.sock
|
||||
* </source>
|
||||
*
|
||||
* Monolog setup:
|
||||
*
|
||||
* $logger = new Monolog\Logger('fluent.tag');
|
||||
* $fluentHandler = new Monolog\Handler\SocketHandler('unix:///var/run/td-agent/td-agent.sock');
|
||||
* $fluentHandler->setFormatter(new Monolog\Formatter\FluentdFormatter());
|
||||
* $logger->pushHandler($fluentHandler);
|
||||
*
|
||||
* @author Andrius Putna <fordnox@gmail.com>
|
||||
*/
|
||||
class FluentdFormatter implements FormatterInterface
|
||||
{
|
||||
/**
|
||||
* @var bool $levelTag should message level be a part of the fluentd tag
|
||||
*/
|
||||
protected $levelTag = \false;
|
||||
public function __construct(bool $levelTag = \false)
|
||||
{
|
||||
if (!\function_exists('json_encode')) {
|
||||
throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s FluentdUnixFormatter');
|
||||
}
|
||||
$this->levelTag = $levelTag;
|
||||
}
|
||||
public function isUsingLevelsInTag() : bool
|
||||
{
|
||||
return $this->levelTag;
|
||||
}
|
||||
public function format(array $record) : string
|
||||
{
|
||||
$tag = $record['channel'];
|
||||
if ($this->levelTag) {
|
||||
$tag .= '.' . \strtolower($record['level_name']);
|
||||
}
|
||||
$message = ['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]);
|
||||
}
|
||||
public function formatBatch(array $records) : string
|
||||
{
|
||||
$message = '';
|
||||
foreach ($records as $record) {
|
||||
$message .= $this->format($record);
|
||||
}
|
||||
return $message;
|
||||
}
|
||||
}
|
||||
41
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/FormatterInterface.php
vendored
Normal file
41
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/FormatterInterface.php
vendored
Normal file
@@ -0,0 +1,41 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
/**
|
||||
* Interface for formatters
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
interface FormatterInterface
|
||||
{
|
||||
/**
|
||||
* Formats a log record.
|
||||
*
|
||||
* @param array $record A record to format
|
||||
* @return mixed The formatted record
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
public function format(array $record);
|
||||
/**
|
||||
* Formats a set of log records.
|
||||
*
|
||||
* @param array $records A set of records to format
|
||||
* @return mixed The formatted set of records
|
||||
*
|
||||
* @phpstan-param Record[] $records
|
||||
*/
|
||||
public function formatBatch(array $records);
|
||||
}
|
||||
138
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/GelfMessageFormatter.php
vendored
Normal file
138
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/GelfMessageFormatter.php
vendored
Normal file
@@ -0,0 +1,138 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Gelf\Message;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Serializes a log message to GELF
|
||||
* @see http://docs.graylog.org/en/latest/pages/gelf.html
|
||||
*
|
||||
* @author Matt Lehner <mlehner@gmail.com>
|
||||
*
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
*/
|
||||
class GelfMessageFormatter extends NormalizerFormatter
|
||||
{
|
||||
protected const DEFAULT_MAX_LENGTH = 32766;
|
||||
/**
|
||||
* @var string the name of the system for the Gelf log message
|
||||
*/
|
||||
protected $systemName;
|
||||
/**
|
||||
* @var string a prefix for 'extra' fields from the Monolog record (optional)
|
||||
*/
|
||||
protected $extraPrefix;
|
||||
/**
|
||||
* @var string a prefix for 'context' fields from the Monolog record (optional)
|
||||
*/
|
||||
protected $contextPrefix;
|
||||
/**
|
||||
* @var int max length per field
|
||||
*/
|
||||
protected $maxLength;
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
private $gelfVersion = 2;
|
||||
/**
|
||||
* Translates Monolog log levels to Graylog2 log priorities.
|
||||
*
|
||||
* @var array<int, int>
|
||||
*
|
||||
* @phpstan-var array<Level, int>
|
||||
*/
|
||||
private $logLevels = [Logger::DEBUG => 7, Logger::INFO => 6, Logger::NOTICE => 5, Logger::WARNING => 4, Logger::ERROR => 3, Logger::CRITICAL => 2, Logger::ALERT => 1, Logger::EMERGENCY => 0];
|
||||
public function __construct(?string $systemName = null, ?string $extraPrefix = null, string $contextPrefix = 'ctxt_', ?int $maxLength = null)
|
||||
{
|
||||
if (!\class_exists(Message::class)) {
|
||||
throw new \RuntimeException('Composer package graylog2/gelf-php is required to use Monolog\'s GelfMessageFormatter');
|
||||
}
|
||||
parent::__construct('U.u');
|
||||
$this->systemName = \is_null($systemName) || $systemName === '' ? (string) \gethostname() : $systemName;
|
||||
$this->extraPrefix = \is_null($extraPrefix) ? '' : $extraPrefix;
|
||||
$this->contextPrefix = $contextPrefix;
|
||||
$this->maxLength = \is_null($maxLength) ? self::DEFAULT_MAX_LENGTH : $maxLength;
|
||||
if (\method_exists(Message::class, 'setFacility')) {
|
||||
$this->gelfVersion = 1;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function format(array $record) : Message
|
||||
{
|
||||
$context = $extra = [];
|
||||
if (isset($record['context'])) {
|
||||
/** @var mixed[] $context */
|
||||
$context = parent::normalize($record['context']);
|
||||
}
|
||||
if (isset($record['extra'])) {
|
||||
/** @var mixed[] $extra */
|
||||
$extra = parent::normalize($record['extra']);
|
||||
}
|
||||
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');
|
||||
}
|
||||
$message = new Message();
|
||||
$message->setTimestamp($record['datetime'])->setShortMessage((string) $record['message'])->setHost($this->systemName)->setLevel($this->logLevels[$record['level']]);
|
||||
// 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));
|
||||
}
|
||||
if ($this->gelfVersion === 1) {
|
||||
if (isset($record['channel'])) {
|
||||
$message->setFacility($record['channel']);
|
||||
}
|
||||
if (isset($extra['line'])) {
|
||||
$message->setLine($extra['line']);
|
||||
unset($extra['line']);
|
||||
}
|
||||
if (isset($extra['file'])) {
|
||||
$message->setFile($extra['file']);
|
||||
unset($extra['file']);
|
||||
}
|
||||
} else {
|
||||
$message->setAdditional('facility', $record['channel']);
|
||||
}
|
||||
foreach ($extra as $key => $val) {
|
||||
$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((string) $val, 0, $this->maxLength));
|
||||
continue;
|
||||
}
|
||||
$message->setAdditional($this->extraPrefix . $key, $val);
|
||||
}
|
||||
foreach ($context as $key => $val) {
|
||||
$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((string) $val, 0, $this->maxLength));
|
||||
continue;
|
||||
}
|
||||
$message->setAdditional($this->contextPrefix . $key, $val);
|
||||
}
|
||||
if ($this->gelfVersion === 1) {
|
||||
/** @phpstan-ignore-next-line */
|
||||
if (null === $message->getFile() && isset($context['exception']['file'])) {
|
||||
if (\preg_match("/^(.+):([0-9]+)\$/", $context['exception']['file'], $matches)) {
|
||||
$message->setFile($matches[1]);
|
||||
$message->setLine($matches[2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return $message;
|
||||
}
|
||||
}
|
||||
36
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/GoogleCloudLoggingFormatter.php
vendored
Normal file
36
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/GoogleCloudLoggingFormatter.php
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DateTimeInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\LogRecord;
|
||||
/**
|
||||
* Encodes message information into JSON in a format compatible with Cloud logging.
|
||||
*
|
||||
* @see https://cloud.google.com/logging/docs/structured-logging
|
||||
* @see https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry
|
||||
*
|
||||
* @author Luís Cobucci <lcobucci@gmail.com>
|
||||
*/
|
||||
final class GoogleCloudLoggingFormatter extends JsonFormatter
|
||||
{
|
||||
/** {@inheritdoc} **/
|
||||
public function format(array $record) : string
|
||||
{
|
||||
// Re-key level for GCP logging
|
||||
$record['severity'] = $record['level_name'];
|
||||
$record['time'] = $record['datetime']->format(DateTimeInterface::RFC3339_EXTENDED);
|
||||
// Remove keys that are not used by GCP
|
||||
unset($record['level'], $record['level_name'], $record['datetime']);
|
||||
return parent::format($record);
|
||||
}
|
||||
}
|
||||
119
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/HtmlFormatter.php
vendored
Normal file
119
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/HtmlFormatter.php
vendored
Normal file
@@ -0,0 +1,119 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Formats incoming records into an HTML table
|
||||
*
|
||||
* This is especially useful for html email logging
|
||||
*
|
||||
* @author Tiago Brito <tlfbrito@gmail.com>
|
||||
*/
|
||||
class HtmlFormatter extends NormalizerFormatter
|
||||
{
|
||||
/**
|
||||
* Translates Monolog log levels to html color priorities.
|
||||
*
|
||||
* @var array<int, string>
|
||||
*/
|
||||
protected $logLevels = [Logger::DEBUG => '#CCCCCC', Logger::INFO => '#28A745', Logger::NOTICE => '#17A2B8', Logger::WARNING => '#FFC107', Logger::ERROR => '#FD7E14', Logger::CRITICAL => '#DC3545', Logger::ALERT => '#821722', Logger::EMERGENCY => '#000000'];
|
||||
/**
|
||||
* @param string|null $dateFormat The format of the timestamp: one supported by DateTime::format
|
||||
*/
|
||||
public function __construct(?string $dateFormat = null)
|
||||
{
|
||||
parent::__construct($dateFormat);
|
||||
}
|
||||
/**
|
||||
* 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
|
||||
*/
|
||||
protected function addRow(string $th, string $td = ' ', bool $escapeTd = \true) : string
|
||||
{
|
||||
$th = \htmlspecialchars($th, \ENT_NOQUOTES, 'UTF-8');
|
||||
if ($escapeTd) {
|
||||
$td = '<pre>' . \htmlspecialchars($td, \ENT_NOQUOTES, 'UTF-8') . '</pre>';
|
||||
}
|
||||
return "<tr style=\"padding: 4px;text-align: left;\">\n<th style=\"vertical-align: top;background: #ccc;color: #000\" width=\"100\">{$th}:</th>\n<td style=\"padding: 4px;text-align: left;vertical-align: top;background: #eee;color: #000\">" . $td . "</td>\n</tr>";
|
||||
}
|
||||
/**
|
||||
* Create a HTML h1 tag
|
||||
*
|
||||
* @param string $title Text to be in the h1
|
||||
* @param int $level Error level
|
||||
* @return string
|
||||
*/
|
||||
protected function addTitle(string $title, int $level) : string
|
||||
{
|
||||
$title = \htmlspecialchars($title, \ENT_NOQUOTES, 'UTF-8');
|
||||
return '<h1 style="background: ' . $this->logLevels[$level] . ';color: #ffffff;padding: 5px;" class="monolog-output">' . $title . '</h1>';
|
||||
}
|
||||
/**
|
||||
* Formats a log record.
|
||||
*
|
||||
* @return string The formatted record
|
||||
*/
|
||||
public function format(array $record) : string
|
||||
{
|
||||
$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('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 .= '</table>';
|
||||
$output .= $this->addRow('Context', $embeddedTable, \false);
|
||||
}
|
||||
if ($record['extra']) {
|
||||
$embeddedTable = '<table cellspacing="1" width="100%">';
|
||||
foreach ($record['extra'] as $key => $value) {
|
||||
$embeddedTable .= $this->addRow((string) $key, $this->convertToString($value));
|
||||
}
|
||||
$embeddedTable .= '</table>';
|
||||
$output .= $this->addRow('Extra', $embeddedTable, \false);
|
||||
}
|
||||
return $output . '</table>';
|
||||
}
|
||||
/**
|
||||
* Formats a set of log records.
|
||||
*
|
||||
* @return string The formatted set of records
|
||||
*/
|
||||
public function formatBatch(array $records) : string
|
||||
{
|
||||
$message = '';
|
||||
foreach ($records as $record) {
|
||||
$message .= $this->format($record);
|
||||
}
|
||||
return $message;
|
||||
}
|
||||
/**
|
||||
* @param mixed $data
|
||||
*/
|
||||
protected function convertToString($data) : string
|
||||
{
|
||||
if (null === $data || \is_scalar($data)) {
|
||||
return (string) $data;
|
||||
}
|
||||
$data = $this->normalize($data);
|
||||
return Utils::jsonEncode($data, \JSON_PRETTY_PRINT | Utils::DEFAULT_JSON_FLAGS, \true);
|
||||
}
|
||||
}
|
||||
196
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/JsonFormatter.php
vendored
Normal file
196
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/JsonFormatter.php
vendored
Normal file
@@ -0,0 +1,196 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use Throwable;
|
||||
/**
|
||||
* Encodes whatever record data is passed to it as json
|
||||
*
|
||||
* This can be useful to log to databases or remote APIs
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class JsonFormatter extends NormalizerFormatter
|
||||
{
|
||||
public const BATCH_MODE_JSON = 1;
|
||||
public const BATCH_MODE_NEWLINES = 2;
|
||||
/** @var self::BATCH_MODE_* */
|
||||
protected $batchMode;
|
||||
/** @var bool */
|
||||
protected $appendNewline;
|
||||
/** @var bool */
|
||||
protected $ignoreEmptyContextAndExtra;
|
||||
/** @var bool */
|
||||
protected $includeStacktraces = \false;
|
||||
/**
|
||||
* @param self::BATCH_MODE_* $batchMode
|
||||
*/
|
||||
public function __construct(int $batchMode = self::BATCH_MODE_JSON, bool $appendNewline = \true, bool $ignoreEmptyContextAndExtra = \false, bool $includeStacktraces = \false)
|
||||
{
|
||||
$this->batchMode = $batchMode;
|
||||
$this->appendNewline = $appendNewline;
|
||||
$this->ignoreEmptyContextAndExtra = $ignoreEmptyContextAndExtra;
|
||||
$this->includeStacktraces = $includeStacktraces;
|
||||
parent::__construct();
|
||||
}
|
||||
/**
|
||||
* The batch mode option configures the formatting style for
|
||||
* multiple records. By default, multiple records will be
|
||||
* formatted as a JSON-encoded array. However, for
|
||||
* compatibility with some API endpoints, alternative styles
|
||||
* are available.
|
||||
*/
|
||||
public function getBatchMode() : int
|
||||
{
|
||||
return $this->batchMode;
|
||||
}
|
||||
/**
|
||||
* True if newlines are appended to every formatted record
|
||||
*/
|
||||
public function isAppendingNewlines() : bool
|
||||
{
|
||||
return $this->appendNewline;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function format(array $record) : string
|
||||
{
|
||||
$normalized = $this->normalize($record);
|
||||
if (isset($normalized['context']) && $normalized['context'] === []) {
|
||||
if ($this->ignoreEmptyContextAndExtra) {
|
||||
unset($normalized['context']);
|
||||
} else {
|
||||
$normalized['context'] = new \stdClass();
|
||||
}
|
||||
}
|
||||
if (isset($normalized['extra']) && $normalized['extra'] === []) {
|
||||
if ($this->ignoreEmptyContextAndExtra) {
|
||||
unset($normalized['extra']);
|
||||
} else {
|
||||
$normalized['extra'] = new \stdClass();
|
||||
}
|
||||
}
|
||||
return $this->toJson($normalized, \true) . ($this->appendNewline ? "\n" : '');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function formatBatch(array $records) : string
|
||||
{
|
||||
switch ($this->batchMode) {
|
||||
case static::BATCH_MODE_NEWLINES:
|
||||
return $this->formatBatchNewlines($records);
|
||||
case static::BATCH_MODE_JSON:
|
||||
default:
|
||||
return $this->formatBatchJson($records);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @return self
|
||||
*/
|
||||
public function includeStacktraces(bool $include = \true) : self
|
||||
{
|
||||
$this->includeStacktraces = $include;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Return a JSON-encoded array of records.
|
||||
*
|
||||
* @phpstan-param Record[] $records
|
||||
*/
|
||||
protected function formatBatchJson(array $records) : string
|
||||
{
|
||||
return $this->toJson($this->normalize($records), \true);
|
||||
}
|
||||
/**
|
||||
* Use new lines to separate records instead of a
|
||||
* JSON-encoded array.
|
||||
*
|
||||
* @phpstan-param Record[] $records
|
||||
*/
|
||||
protected function formatBatchNewlines(array $records) : string
|
||||
{
|
||||
$instance = $this;
|
||||
$oldNewline = $this->appendNewline;
|
||||
$this->appendNewline = \false;
|
||||
\array_walk($records, function (&$value, $key) use($instance) {
|
||||
$value = $instance->format($value);
|
||||
});
|
||||
$this->appendNewline = $oldNewline;
|
||||
return \implode("\n", $records);
|
||||
}
|
||||
/**
|
||||
* Normalizes given $data.
|
||||
*
|
||||
* @param mixed $data
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
protected function normalize($data, int $depth = 0)
|
||||
{
|
||||
if ($depth > $this->maxNormalizeDepth) {
|
||||
return 'Over ' . $this->maxNormalizeDepth . ' levels deep, aborting normalization';
|
||||
}
|
||||
if (\is_array($data)) {
|
||||
$normalized = [];
|
||||
$count = 1;
|
||||
foreach ($data as $key => $value) {
|
||||
if ($count++ > $this->maxNormalizeItemCount) {
|
||||
$normalized['...'] = 'Over ' . $this->maxNormalizeItemCount . ' items (' . \count($data) . ' total), aborting normalization';
|
||||
break;
|
||||
}
|
||||
$normalized[$key] = $this->normalize($value, $depth + 1);
|
||||
}
|
||||
return $normalized;
|
||||
}
|
||||
if (\is_object($data)) {
|
||||
if ($data instanceof \DateTimeInterface) {
|
||||
return $this->formatDate($data);
|
||||
}
|
||||
if ($data instanceof Throwable) {
|
||||
return $this->normalizeException($data, $depth);
|
||||
}
|
||||
// if the object has specific json serializability we want to make sure we skip the __toString treatment below
|
||||
if ($data instanceof \JsonSerializable) {
|
||||
return $data;
|
||||
}
|
||||
if (\get_class($data) === '__PHP_Incomplete_Class') {
|
||||
return new \ArrayObject($data);
|
||||
}
|
||||
if (\method_exists($data, '__toString')) {
|
||||
return $data->__toString();
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
if (\is_resource($data)) {
|
||||
return parent::normalize($data);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
/**
|
||||
* Normalizes given exception with or without its own stack trace based on
|
||||
* `includeStacktraces` property.
|
||||
*
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function normalizeException(Throwable $e, int $depth = 0) : array
|
||||
{
|
||||
$data = parent::normalizeException($e, $depth);
|
||||
if (!$this->includeStacktraces) {
|
||||
unset($data['trace']);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
}
|
||||
206
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LineFormatter.php
vendored
Normal file
206
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LineFormatter.php
vendored
Normal file
@@ -0,0 +1,206 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Formats incoming records into a one-line string
|
||||
*
|
||||
* This is especially useful for logging to files
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
*/
|
||||
class LineFormatter extends NormalizerFormatter
|
||||
{
|
||||
public const SIMPLE_FORMAT = "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n";
|
||||
/** @var string */
|
||||
protected $format;
|
||||
/** @var bool */
|
||||
protected $allowInlineLineBreaks;
|
||||
/** @var bool */
|
||||
protected $ignoreEmptyContextAndExtra;
|
||||
/** @var bool */
|
||||
protected $includeStacktraces;
|
||||
/** @var ?callable */
|
||||
protected $stacktracesParser;
|
||||
/**
|
||||
* @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
|
||||
*/
|
||||
public function __construct(?string $format = null, ?string $dateFormat = null, bool $allowInlineLineBreaks = \false, bool $ignoreEmptyContextAndExtra = \false, bool $includeStacktraces = \false)
|
||||
{
|
||||
$this->format = $format === null ? static::SIMPLE_FORMAT : $format;
|
||||
$this->allowInlineLineBreaks = $allowInlineLineBreaks;
|
||||
$this->ignoreEmptyContextAndExtra = $ignoreEmptyContextAndExtra;
|
||||
$this->includeStacktraces($includeStacktraces);
|
||||
parent::__construct($dateFormat);
|
||||
}
|
||||
public function includeStacktraces(bool $include = \true, ?callable $parser = null) : self
|
||||
{
|
||||
$this->includeStacktraces = $include;
|
||||
if ($this->includeStacktraces) {
|
||||
$this->allowInlineLineBreaks = \true;
|
||||
$this->stacktracesParser = $parser;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
public function allowInlineLineBreaks(bool $allow = \true) : self
|
||||
{
|
||||
$this->allowInlineLineBreaks = $allow;
|
||||
return $this;
|
||||
}
|
||||
public function ignoreEmptyContextAndExtra(bool $ignore = \true) : self
|
||||
{
|
||||
$this->ignoreEmptyContextAndExtra = $ignore;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function format(array $record) : string
|
||||
{
|
||||
$vars = parent::format($record);
|
||||
$output = $this->format;
|
||||
foreach ($vars['extra'] as $var => $val) {
|
||||
if (\false !== \strpos($output, '%extra.' . $var . '%')) {
|
||||
$output = \str_replace('%extra.' . $var . '%', $this->stringify($val), $output);
|
||||
unset($vars['extra'][$var]);
|
||||
}
|
||||
}
|
||||
foreach ($vars['context'] as $var => $val) {
|
||||
if (\false !== \strpos($output, '%context.' . $var . '%')) {
|
||||
$output = \str_replace('%context.' . $var . '%', $this->stringify($val), $output);
|
||||
unset($vars['context'][$var]);
|
||||
}
|
||||
}
|
||||
if ($this->ignoreEmptyContextAndExtra) {
|
||||
if (empty($vars['context'])) {
|
||||
unset($vars['context']);
|
||||
$output = \str_replace('%context%', '', $output);
|
||||
}
|
||||
if (empty($vars['extra'])) {
|
||||
unset($vars['extra']);
|
||||
$output = \str_replace('%extra%', '', $output);
|
||||
}
|
||||
}
|
||||
foreach ($vars as $var => $val) {
|
||||
if (\false !== \strpos($output, '%' . $var . '%')) {
|
||||
$output = \str_replace('%' . $var . '%', $this->stringify($val), $output);
|
||||
}
|
||||
}
|
||||
// remove leftover %extra.xxx% and %context.xxx% if any
|
||||
if (\false !== \strpos($output, '%')) {
|
||||
$output = \preg_replace('/%(?:extra|context)\\..+?%/', '', $output);
|
||||
if (null === $output) {
|
||||
$pcreErrorCode = \preg_last_error();
|
||||
throw new \RuntimeException('Failed to run preg_replace: ' . $pcreErrorCode . ' / ' . Utils::pcreLastErrorMessage($pcreErrorCode));
|
||||
}
|
||||
}
|
||||
return $output;
|
||||
}
|
||||
public function formatBatch(array $records) : string
|
||||
{
|
||||
$message = '';
|
||||
foreach ($records as $record) {
|
||||
$message .= $this->format($record);
|
||||
}
|
||||
return $message;
|
||||
}
|
||||
/**
|
||||
* @param mixed $value
|
||||
*/
|
||||
public function stringify($value) : string
|
||||
{
|
||||
return $this->replaceNewlines($this->convertToString($value));
|
||||
}
|
||||
protected function normalizeException(\Throwable $e, int $depth = 0) : string
|
||||
{
|
||||
$str = $this->formatException($e);
|
||||
if ($previous = $e->getPrevious()) {
|
||||
do {
|
||||
$depth++;
|
||||
if ($depth > $this->maxNormalizeDepth) {
|
||||
$str .= "\n[previous exception] Over " . $this->maxNormalizeDepth . ' levels deep, aborting normalization';
|
||||
break;
|
||||
}
|
||||
$str .= "\n[previous exception] " . $this->formatException($previous);
|
||||
} while ($previous = $previous->getPrevious());
|
||||
}
|
||||
return $str;
|
||||
}
|
||||
/**
|
||||
* @param mixed $data
|
||||
*/
|
||||
protected function convertToString($data) : string
|
||||
{
|
||||
if (null === $data || \is_bool($data)) {
|
||||
return \var_export($data, \true);
|
||||
}
|
||||
if (\is_scalar($data)) {
|
||||
return (string) $data;
|
||||
}
|
||||
return $this->toJson($data, \true);
|
||||
}
|
||||
protected function replaceNewlines(string $str) : string
|
||||
{
|
||||
if ($this->allowInlineLineBreaks) {
|
||||
if (0 === \strpos($str, '{')) {
|
||||
$str = \preg_replace('/(?<!\\\\)\\\\[rn]/', "\n", $str);
|
||||
if (null === $str) {
|
||||
$pcreErrorCode = \preg_last_error();
|
||||
throw new \RuntimeException('Failed to run preg_replace: ' . $pcreErrorCode . ' / ' . Utils::pcreLastErrorMessage($pcreErrorCode));
|
||||
}
|
||||
}
|
||||
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)) {
|
||||
if (\is_string($e->detail)) {
|
||||
$str .= ' detail: ' . $e->detail;
|
||||
} elseif (\is_object($e->detail) || \is_array($e->detail)) {
|
||||
$str .= ' detail: ' . $this->toJson($e->detail, \true);
|
||||
}
|
||||
}
|
||||
}
|
||||
$str .= '): ' . $e->getMessage() . ' at ' . $e->getFile() . ':' . $e->getLine() . ')';
|
||||
if ($this->includeStacktraces) {
|
||||
$str .= $this->stacktracesParser($e);
|
||||
}
|
||||
return $str;
|
||||
}
|
||||
private function stacktracesParser(\Throwable $e) : string
|
||||
{
|
||||
$trace = $e->getTraceAsString();
|
||||
if ($this->stacktracesParser) {
|
||||
$trace = $this->stacktracesParserCustom($trace);
|
||||
}
|
||||
return "\n[stacktrace]\n" . $trace . "\n";
|
||||
}
|
||||
private function stacktracesParserCustom(string $trace) : string
|
||||
{
|
||||
return \implode("\n", \array_filter(\array_map($this->stacktracesParser, \explode("\n", $trace))));
|
||||
}
|
||||
}
|
||||
43
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LogglyFormatter.php
vendored
Normal file
43
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LogglyFormatter.php
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
/**
|
||||
* Encodes message information into JSON in a format compatible with Loggly.
|
||||
*
|
||||
* @author Adam Pancutt <adam@pancutt.com>
|
||||
*/
|
||||
class LogglyFormatter extends JsonFormatter
|
||||
{
|
||||
/**
|
||||
* Overrides the default batch mode to new lines for compatibility with the
|
||||
* Loggly bulk API.
|
||||
*/
|
||||
public function __construct(int $batchMode = self::BATCH_MODE_NEWLINES, bool $appendNewline = \false)
|
||||
{
|
||||
parent::__construct($batchMode, $appendNewline);
|
||||
}
|
||||
/**
|
||||
* Appends the 'timestamp' parameter for indexing by Loggly.
|
||||
*
|
||||
* @see https://www.loggly.com/docs/automated-parsing/#json
|
||||
* @see \Monolog\Formatter\JsonFormatter::format()
|
||||
*/
|
||||
public function format(array $record) : string
|
||||
{
|
||||
if (isset($record["datetime"]) && $record["datetime"] instanceof \DateTimeInterface) {
|
||||
$record["timestamp"] = $record["datetime"]->format("Y-m-d\\TH:i:s.uO");
|
||||
unset($record["datetime"]);
|
||||
}
|
||||
return parent::format($record);
|
||||
}
|
||||
}
|
||||
57
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LogmaticFormatter.php
vendored
Normal file
57
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LogmaticFormatter.php
vendored
Normal file
@@ -0,0 +1,57 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\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);
|
||||
}
|
||||
}
|
||||
89
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LogstashFormatter.php
vendored
Normal file
89
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/LogstashFormatter.php
vendored
Normal file
@@ -0,0 +1,89 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\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
|
||||
*
|
||||
* @author Tim Mower <timothy.mower@gmail.com>
|
||||
*/
|
||||
class LogstashFormatter extends NormalizerFormatter
|
||||
{
|
||||
/**
|
||||
* @var string the name of the system for the Logstash log message, used to fill the @source field
|
||||
*/
|
||||
protected $systemName;
|
||||
/**
|
||||
* @var string an application name for the Logstash log message, used to fill the @type field
|
||||
*/
|
||||
protected $applicationName;
|
||||
/**
|
||||
* @var string the key for 'extra' fields from the Monolog record
|
||||
*/
|
||||
protected $extraKey;
|
||||
/**
|
||||
* @var string the key for 'context' fields from the Monolog record
|
||||
*/
|
||||
protected $contextKey;
|
||||
/**
|
||||
* @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
|
||||
*/
|
||||
public function __construct(string $applicationName, ?string $systemName = null, string $extraKey = 'extra', string $contextKey = 'context')
|
||||
{
|
||||
// logstash requires a ISO 8601 format date with optional millisecond precision.
|
||||
parent::__construct('Y-m-d\\TH:i:s.uP');
|
||||
$this->systemName = $systemName === null ? (string) \gethostname() : $systemName;
|
||||
$this->applicationName = $applicationName;
|
||||
$this->extraKey = $extraKey;
|
||||
$this->contextKey = $contextKey;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function format(array $record) : string
|
||||
{
|
||||
$record = parent::format($record);
|
||||
if (empty($record['datetime'])) {
|
||||
$record['datetime'] = \gmdate('c');
|
||||
}
|
||||
$message = ['@timestamp' => $record['datetime'], '@version' => 1, 'host' => $this->systemName];
|
||||
if (isset($record['message'])) {
|
||||
$message['message'] = $record['message'];
|
||||
}
|
||||
if (isset($record['channel'])) {
|
||||
$message['type'] = $record['channel'];
|
||||
$message['channel'] = $record['channel'];
|
||||
}
|
||||
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'];
|
||||
}
|
||||
if (!empty($record['context'])) {
|
||||
$message[$this->contextKey] = $record['context'];
|
||||
}
|
||||
return $this->toJson($message) . "\n";
|
||||
}
|
||||
}
|
||||
134
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/MongoDBFormatter.php
vendored
Normal file
134
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/MongoDBFormatter.php
vendored
Normal file
@@ -0,0 +1,134 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use MongoDB\BSON\Type;
|
||||
use MongoDB\BSON\UTCDateTime;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Formats a record for use with the MongoDBHandler.
|
||||
*
|
||||
* @author Florian Plattner <me@florianplattner.de>
|
||||
*/
|
||||
class MongoDBFormatter implements FormatterInterface
|
||||
{
|
||||
/** @var bool */
|
||||
private $exceptionTraceAsString;
|
||||
/** @var int */
|
||||
private $maxNestingLevel;
|
||||
/** @var bool */
|
||||
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)
|
||||
{
|
||||
$this->maxNestingLevel = \max($maxNestingLevel, 0);
|
||||
$this->exceptionTraceAsString = $exceptionTraceAsString;
|
||||
$this->isLegacyMongoExt = \extension_loaded('mongodb') && \version_compare((string) \phpversion('mongodb'), '1.1.9', '<=');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function format(array $record) : array
|
||||
{
|
||||
/** @var mixed[] $res */
|
||||
$res = $this->formatArray($record);
|
||||
return $res;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @return array<mixed[]>
|
||||
*/
|
||||
public function formatBatch(array $records) : array
|
||||
{
|
||||
$formatted = [];
|
||||
foreach ($records as $key => $record) {
|
||||
$formatted[$key] = $this->format($record);
|
||||
}
|
||||
return $formatted;
|
||||
}
|
||||
/**
|
||||
* @param mixed[] $array
|
||||
* @return mixed[]|string Array except when max nesting level is reached then a string "[...]"
|
||||
*/
|
||||
protected function formatArray(array $array, int $nestingLevel = 0)
|
||||
{
|
||||
if ($this->maxNestingLevel > 0 && $nestingLevel > $this->maxNestingLevel) {
|
||||
return '[...]';
|
||||
}
|
||||
foreach ($array as $name => $value) {
|
||||
if ($value instanceof \DateTimeInterface) {
|
||||
$array[$name] = $this->formatDate($value, $nestingLevel + 1);
|
||||
} elseif ($value instanceof \Throwable) {
|
||||
$array[$name] = $this->formatException($value, $nestingLevel + 1);
|
||||
} elseif (\is_array($value)) {
|
||||
$array[$name] = $this->formatArray($value, $nestingLevel + 1);
|
||||
} elseif (\is_object($value) && !$value instanceof Type) {
|
||||
$array[$name] = $this->formatObject($value, $nestingLevel + 1);
|
||||
}
|
||||
}
|
||||
return $array;
|
||||
}
|
||||
/**
|
||||
* @param mixed $value
|
||||
* @return mixed[]|string
|
||||
*/
|
||||
protected function formatObject($value, int $nestingLevel)
|
||||
{
|
||||
$objectVars = \get_object_vars($value);
|
||||
$objectVars['class'] = Utils::getClass($value);
|
||||
return $this->formatArray($objectVars, $nestingLevel);
|
||||
}
|
||||
/**
|
||||
* @return mixed[]|string
|
||||
*/
|
||||
protected function formatException(\Throwable $exception, int $nestingLevel)
|
||||
{
|
||||
$formattedException = ['class' => Utils::getClass($exception), 'message' => $exception->getMessage(), 'code' => (int) $exception->getCode(), 'file' => $exception->getFile() . ':' . $exception->getLine()];
|
||||
if ($this->exceptionTraceAsString === \true) {
|
||||
$formattedException['trace'] = $exception->getTraceAsString();
|
||||
} else {
|
||||
$formattedException['trace'] = $exception->getTrace();
|
||||
}
|
||||
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
|
||||
{
|
||||
return new UTCDateTime((int) \floor((float) $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((float) $value->format('U.u') * 1000);
|
||||
$milliseconds = \PHP_INT_SIZE == 8 ? (int) $milliseconds : (string) $milliseconds;
|
||||
// @phpstan-ignore-next-line
|
||||
return new UTCDateTime($milliseconds);
|
||||
}
|
||||
}
|
||||
238
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/NormalizerFormatter.php
vendored
Normal file
238
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/NormalizerFormatter.php
vendored
Normal file
@@ -0,0 +1,238 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\DateTimeImmutable;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use Throwable;
|
||||
/**
|
||||
* Normalizes incoming records to remove objects/resources so it's easier to dump to various targets
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*/
|
||||
class NormalizerFormatter implements FormatterInterface
|
||||
{
|
||||
public const SIMPLE_DATE = "Y-m-d\\TH:i:sP";
|
||||
/** @var string */
|
||||
protected $dateFormat;
|
||||
/** @var int */
|
||||
protected $maxNormalizeDepth = 9;
|
||||
/** @var int */
|
||||
protected $maxNormalizeItemCount = 1000;
|
||||
/** @var int */
|
||||
private $jsonEncodeOptions = Utils::DEFAULT_JSON_FLAGS;
|
||||
/**
|
||||
* @param string|null $dateFormat The format of the timestamp: one supported by DateTime::format
|
||||
*/
|
||||
public function __construct(?string $dateFormat = null)
|
||||
{
|
||||
$this->dateFormat = null === $dateFormat ? static::SIMPLE_DATE : $dateFormat;
|
||||
if (!\function_exists('json_encode')) {
|
||||
throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s NormalizerFormatter');
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @param mixed[] $record
|
||||
*/
|
||||
public function format(array $record)
|
||||
{
|
||||
return $this->normalize($record);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function formatBatch(array $records)
|
||||
{
|
||||
foreach ($records as $key => $record) {
|
||||
$records[$key] = $this->format($record);
|
||||
}
|
||||
return $records;
|
||||
}
|
||||
public function getDateFormat() : string
|
||||
{
|
||||
return $this->dateFormat;
|
||||
}
|
||||
public function setDateFormat(string $dateFormat) : self
|
||||
{
|
||||
$this->dateFormat = $dateFormat;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* 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 null|scalar|array<array|scalar|null>
|
||||
*/
|
||||
protected function normalize($data, int $depth = 0)
|
||||
{
|
||||
if ($depth > $this->maxNormalizeDepth) {
|
||||
return 'Over ' . $this->maxNormalizeDepth . ' levels deep, aborting normalization';
|
||||
}
|
||||
if (null === $data || \is_scalar($data)) {
|
||||
if (\is_float($data)) {
|
||||
if (\is_infinite($data)) {
|
||||
return ($data > 0 ? '' : '-') . 'INF';
|
||||
}
|
||||
if (\is_nan($data)) {
|
||||
return 'NaN';
|
||||
}
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
if (\is_array($data)) {
|
||||
$normalized = [];
|
||||
$count = 1;
|
||||
foreach ($data as $key => $value) {
|
||||
if ($count++ > $this->maxNormalizeItemCount) {
|
||||
$normalized['...'] = 'Over ' . $this->maxNormalizeItemCount . ' items (' . \count($data) . ' total), aborting normalization';
|
||||
break;
|
||||
}
|
||||
$normalized[$key] = $this->normalize($value, $depth + 1);
|
||||
}
|
||||
return $normalized;
|
||||
}
|
||||
if ($data instanceof \DateTimeInterface) {
|
||||
return $this->formatDate($data);
|
||||
}
|
||||
if (\is_object($data)) {
|
||||
if ($data instanceof Throwable) {
|
||||
return $this->normalizeException($data, $depth);
|
||||
}
|
||||
if ($data instanceof \JsonSerializable) {
|
||||
/** @var null|scalar|array<array|scalar|null> $value */
|
||||
$value = $data->jsonSerialize();
|
||||
} elseif (\get_class($data) === '__PHP_Incomplete_Class') {
|
||||
$accessor = new \ArrayObject($data);
|
||||
$value = (string) $accessor['__PHP_Incomplete_Class_Name'];
|
||||
} elseif (\method_exists($data, '__toString')) {
|
||||
/** @var string $value */
|
||||
$value = $data->__toString();
|
||||
} else {
|
||||
// the rest is normalized by json encoding and decoding it
|
||||
/** @var null|scalar|array<array|scalar|null> $value */
|
||||
$value = \json_decode($this->toJson($data, \true), \true);
|
||||
}
|
||||
return [Utils::getClass($data) => $value];
|
||||
}
|
||||
if (\is_resource($data)) {
|
||||
return \sprintf('[resource(%s)]', \get_resource_type($data));
|
||||
}
|
||||
return '[unknown(' . \gettype($data) . ')]';
|
||||
}
|
||||
/**
|
||||
* @return mixed[]
|
||||
*/
|
||||
protected function normalizeException(Throwable $e, int $depth = 0)
|
||||
{
|
||||
if ($depth > $this->maxNormalizeDepth) {
|
||||
return ['Over ' . $this->maxNormalizeDepth . ' levels deep, aborting normalization'];
|
||||
}
|
||||
if ($e instanceof \JsonSerializable) {
|
||||
return (array) $e->jsonSerialize();
|
||||
}
|
||||
$data = ['class' => Utils::getClass($e), 'message' => $e->getMessage(), 'code' => (int) $e->getCode(), 'file' => $e->getFile() . ':' . $e->getLine()];
|
||||
if ($e instanceof \SoapFault) {
|
||||
if (isset($e->faultcode)) {
|
||||
$data['faultcode'] = $e->faultcode;
|
||||
}
|
||||
if (isset($e->faultactor)) {
|
||||
$data['faultactor'] = $e->faultactor;
|
||||
}
|
||||
if (isset($e->detail)) {
|
||||
if (\is_string($e->detail)) {
|
||||
$data['detail'] = $e->detail;
|
||||
} elseif (\is_object($e->detail) || \is_array($e->detail)) {
|
||||
$data['detail'] = $this->toJson($e->detail, \true);
|
||||
}
|
||||
}
|
||||
}
|
||||
$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, $depth + 1);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
/**
|
||||
* Return the JSON representation of a value
|
||||
*
|
||||
* @param mixed $data
|
||||
* @throws \RuntimeException if encoding fails and errors are not ignored
|
||||
* @return string if encoding fails and ignoreErrors is true 'null' is returned
|
||||
*/
|
||||
protected function toJson($data, bool $ignoreErrors = \false) : string
|
||||
{
|
||||
return Utils::jsonEncode($data, $this->jsonEncodeOptions, $ignoreErrors);
|
||||
}
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
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);
|
||||
}
|
||||
public function addJsonEncodeOption(int $option) : self
|
||||
{
|
||||
$this->jsonEncodeOptions |= $option;
|
||||
return $this;
|
||||
}
|
||||
public function removeJsonEncodeOption(int $option) : self
|
||||
{
|
||||
$this->jsonEncodeOptions &= ~$option;
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
47
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ScalarFormatter.php
vendored
Normal file
47
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/ScalarFormatter.php
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
/**
|
||||
* Formats data into an associative array of scalar values.
|
||||
* Objects and arrays will be JSON encoded.
|
||||
*
|
||||
* @author Andrew Lawson <adlawson@gmail.com>
|
||||
*/
|
||||
class ScalarFormatter extends NormalizerFormatter
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @phpstan-return array<string, scalar|null> $record
|
||||
*/
|
||||
public function format(array $record) : array
|
||||
{
|
||||
$result = [];
|
||||
foreach ($record as $key => $value) {
|
||||
$result[$key] = $this->normalizeValue($value);
|
||||
}
|
||||
return $result;
|
||||
}
|
||||
/**
|
||||
* @param mixed $value
|
||||
* @return scalar|null
|
||||
*/
|
||||
protected function normalizeValue($value)
|
||||
{
|
||||
$normalized = $this->normalize($value);
|
||||
if (\is_array($normalized)) {
|
||||
return $this->toJson($normalized, \true);
|
||||
}
|
||||
return $normalized;
|
||||
}
|
||||
}
|
||||
107
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/WildfireFormatter.php
vendored
Normal file
107
vendor/Gcp/monolog/monolog/src/Monolog/Formatter/WildfireFormatter.php
vendored
Normal file
@@ -0,0 +1,107 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Serializes a log message according to Wildfire's header requirements
|
||||
*
|
||||
* @author Eric Clemmons (@ericclemmons) <eric@uxdriven.com>
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
* @author Kirill chEbba Chebunin <iam@chebba.org>
|
||||
*
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
*/
|
||||
class WildfireFormatter extends NormalizerFormatter
|
||||
{
|
||||
/**
|
||||
* Translates Monolog log levels to Wildfire levels.
|
||||
*
|
||||
* @var array<Level, string>
|
||||
*/
|
||||
private $logLevels = [Logger::DEBUG => 'LOG', Logger::INFO => 'INFO', Logger::NOTICE => 'INFO', Logger::WARNING => 'WARN', Logger::ERROR => 'ERROR', Logger::CRITICAL => 'ERROR', Logger::ALERT => 'ERROR', Logger::EMERGENCY => 'ERROR'];
|
||||
/**
|
||||
* @param string|null $dateFormat The format of the timestamp: one supported by DateTime::format
|
||||
*/
|
||||
public function __construct(?string $dateFormat = null)
|
||||
{
|
||||
parent::__construct($dateFormat);
|
||||
// http headers do not like non-ISO-8559-1 characters
|
||||
$this->removeJsonEncodeOption(\JSON_UNESCAPED_UNICODE);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function format(array $record) : string
|
||||
{
|
||||
// Retrieve the line and file if set and remove them from the formatted extra
|
||||
$file = $line = '';
|
||||
if (isset($record['extra']['file'])) {
|
||||
$file = $record['extra']['file'];
|
||||
unset($record['extra']['file']);
|
||||
}
|
||||
if (isset($record['extra']['line'])) {
|
||||
$line = $record['extra']['line'];
|
||||
unset($record['extra']['line']);
|
||||
}
|
||||
/** @var mixed[] $record */
|
||||
$record = $this->normalize($record);
|
||||
$message = ['message' => $record['message']];
|
||||
$handleError = \false;
|
||||
if ($record['context']) {
|
||||
$message['context'] = $record['context'];
|
||||
$handleError = \true;
|
||||
}
|
||||
if ($record['extra']) {
|
||||
$message['extra'] = $record['extra'];
|
||||
$handleError = \true;
|
||||
}
|
||||
if (\count($message) === 1) {
|
||||
$message = \reset($message);
|
||||
}
|
||||
if (isset($record['context']['table'])) {
|
||||
$type = 'TABLE';
|
||||
$label = $record['channel'] . ': ' . $record['message'];
|
||||
$message = $record['context']['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([['Type' => $type, 'File' => $file, 'Line' => $line, 'Label' => $label], $message], $handleError);
|
||||
// The message itself is a serialization of the above JSON object + it's length
|
||||
return \sprintf('%d|%s|', \strlen($json), $json);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @phpstan-return never
|
||||
*/
|
||||
public function formatBatch(array $records)
|
||||
{
|
||||
throw new \BadMethodCallException('Batch formatting does not make sense for the WildfireFormatter');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @return null|scalar|array<array|scalar|null>|object
|
||||
*/
|
||||
protected function normalize($data, int $depth = 0)
|
||||
{
|
||||
if (\is_object($data) && !$data instanceof \DateTimeInterface) {
|
||||
return $data;
|
||||
}
|
||||
return parent::normalize($data, $depth);
|
||||
}
|
||||
}
|
||||
102
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AbstractHandler.php
vendored
Normal file
102
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AbstractHandler.php
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\ResettableInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Base Handler class providing basic level/bubble support
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
abstract class AbstractHandler extends Handler implements ResettableInterface
|
||||
{
|
||||
/**
|
||||
* @var int
|
||||
* @phpstan-var Level
|
||||
*/
|
||||
protected $level = Logger::DEBUG;
|
||||
/** @var bool */
|
||||
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
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function __construct($level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
$this->setLevel($level);
|
||||
$this->bubble = $bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
return $record['level'] >= $this->level;
|
||||
}
|
||||
/**
|
||||
* Sets minimum logging level at which this handler will be triggered.
|
||||
*
|
||||
* @param Level|LevelName|LogLevel::* $level Level or level name
|
||||
* @return self
|
||||
*/
|
||||
public function setLevel($level) : self
|
||||
{
|
||||
$this->level = Logger::toMonologLevel($level);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Gets minimum logging level at which this handler will be triggered.
|
||||
*
|
||||
* @return int
|
||||
*
|
||||
* @phpstan-return Level
|
||||
*/
|
||||
public function getLevel() : int
|
||||
{
|
||||
return $this->level;
|
||||
}
|
||||
/**
|
||||
* Sets the bubbling behavior.
|
||||
*
|
||||
* @param bool $bubble true means that this handler allows bubbling.
|
||||
* false means that bubbling is not permitted.
|
||||
* @return self
|
||||
*/
|
||||
public function setBubble(bool $bubble) : self
|
||||
{
|
||||
$this->bubble = $bubble;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Gets the bubbling behavior.
|
||||
*
|
||||
* @return bool true means that this handler allows bubbling.
|
||||
* false means that bubbling is not permitted.
|
||||
*/
|
||||
public function getBubble() : bool
|
||||
{
|
||||
return $this->bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
}
|
||||
}
|
||||
61
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AbstractProcessingHandler.php
vendored
Normal file
61
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AbstractProcessingHandler.php
vendored
Normal file
@@ -0,0 +1,61 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
/**
|
||||
* Base Handler class providing the Handler structure, including processors and formatters
|
||||
*
|
||||
* Classes extending it should (in most cases) only implement write($record)
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
*
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-type FormattedRecord array{message: string, context: mixed[], level: Level, level_name: LevelName, channel: string, datetime: \DateTimeImmutable, extra: mixed[], formatted: mixed}
|
||||
*/
|
||||
abstract class AbstractProcessingHandler extends AbstractHandler implements ProcessableHandlerInterface, FormattableHandlerInterface
|
||||
{
|
||||
use ProcessableHandlerTrait;
|
||||
use FormattableHandlerTrait;
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if (!$this->isHandling($record)) {
|
||||
return \false;
|
||||
}
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
$record['formatted'] = $this->getFormatter()->format($record);
|
||||
$this->write($record);
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* Writes the record down to the log of the implementing handler
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
protected abstract function write(array $record) : void;
|
||||
/**
|
||||
* @return void
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
parent::reset();
|
||||
$this->resetProcessors();
|
||||
}
|
||||
}
|
||||
85
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AbstractSyslogHandler.php
vendored
Normal file
85
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AbstractSyslogHandler.php
vendored
Normal file
@@ -0,0 +1,85 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
/**
|
||||
* Common syslog functionality
|
||||
*
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
*/
|
||||
abstract class AbstractSyslogHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var int */
|
||||
protected $facility;
|
||||
/**
|
||||
* Translates Monolog log levels to syslog log priorities.
|
||||
* @var array
|
||||
* @phpstan-var array<Level, int>
|
||||
*/
|
||||
protected $logLevels = [Logger::DEBUG => \LOG_DEBUG, Logger::INFO => \LOG_INFO, Logger::NOTICE => \LOG_NOTICE, Logger::WARNING => \LOG_WARNING, Logger::ERROR => \LOG_ERR, Logger::CRITICAL => \LOG_CRIT, Logger::ALERT => \LOG_ALERT, Logger::EMERGENCY => \LOG_EMERG];
|
||||
/**
|
||||
* List of valid log facility names.
|
||||
* @var array<string, int>
|
||||
*/
|
||||
protected $facilities = ['auth' => \LOG_AUTH, 'authpriv' => \LOG_AUTHPRIV, 'cron' => \LOG_CRON, 'daemon' => \LOG_DAEMON, 'kern' => \LOG_KERN, 'lpr' => \LOG_LPR, 'mail' => \LOG_MAIL, 'news' => \LOG_NEWS, '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
|
||||
*/
|
||||
public function __construct($facility = \LOG_USER, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
if (!\defined('PHP_WINDOWS_VERSION_BUILD')) {
|
||||
$this->facilities['local0'] = \LOG_LOCAL0;
|
||||
$this->facilities['local1'] = \LOG_LOCAL1;
|
||||
$this->facilities['local2'] = \LOG_LOCAL2;
|
||||
$this->facilities['local3'] = \LOG_LOCAL3;
|
||||
$this->facilities['local4'] = \LOG_LOCAL4;
|
||||
$this->facilities['local5'] = \LOG_LOCAL5;
|
||||
$this->facilities['local6'] = \LOG_LOCAL6;
|
||||
$this->facilities['local7'] = \LOG_LOCAL7;
|
||||
} else {
|
||||
$this->facilities['local0'] = 128;
|
||||
// LOG_LOCAL0
|
||||
$this->facilities['local1'] = 136;
|
||||
// LOG_LOCAL1
|
||||
$this->facilities['local2'] = 144;
|
||||
// LOG_LOCAL2
|
||||
$this->facilities['local3'] = 152;
|
||||
// LOG_LOCAL3
|
||||
$this->facilities['local4'] = 160;
|
||||
// LOG_LOCAL4
|
||||
$this->facilities['local5'] = 168;
|
||||
// LOG_LOCAL5
|
||||
$this->facilities['local6'] = 176;
|
||||
// LOG_LOCAL6
|
||||
$this->facilities['local7'] = 184;
|
||||
// LOG_LOCAL7
|
||||
}
|
||||
// convert textual description of facility to syslog constant
|
||||
if (\is_string($facility) && \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');
|
||||
}
|
||||
$this->facility = $facility;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter('%channel%.%level_name%: %message% %context% %extra%');
|
||||
}
|
||||
}
|
||||
134
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AmqpHandler.php
vendored
Normal file
134
vendor/Gcp/monolog/monolog/src/Monolog/Handler/AmqpHandler.php
vendored
Normal file
@@ -0,0 +1,134 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\JsonFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\PhpAmqpLib\Message\AMQPMessage;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\PhpAmqpLib\Channel\AMQPChannel;
|
||||
use AMQPExchange;
|
||||
/**
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class AmqpHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* @var AMQPExchange|AMQPChannel $exchange
|
||||
*/
|
||||
protected $exchange;
|
||||
/** @var array<string, mixed> */
|
||||
private $extraAttributes = [];
|
||||
/**
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
public function getExtraAttributes() : array
|
||||
{
|
||||
return $this->extraAttributes;
|
||||
}
|
||||
/**
|
||||
* Configure extra attributes to pass to the AMQPExchange (if you are using the amqp extension)
|
||||
*
|
||||
* @param array<string, mixed> $extraAttributes One of content_type, content_encoding,
|
||||
* message_id, user_id, app_id, delivery_mode,
|
||||
* priority, timestamp, expiration, type
|
||||
* or reply_to, headers.
|
||||
* @return AmqpHandler
|
||||
*/
|
||||
public function setExtraAttributes(array $extraAttributes) : self
|
||||
{
|
||||
$this->extraAttributes = $extraAttributes;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $exchangeName;
|
||||
/**
|
||||
* @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
|
||||
*/
|
||||
public function __construct($exchange, ?string $exchangeName = null, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
if ($exchange instanceof AMQPChannel) {
|
||||
$this->exchangeName = (string) $exchangeName;
|
||||
} elseif (!$exchange instanceof AMQPExchange) {
|
||||
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;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$data = $record["formatted"];
|
||||
$routingKey = $this->getRoutingKey($record);
|
||||
if ($this->exchange instanceof AMQPExchange) {
|
||||
$attributes = ['delivery_mode' => 2, 'content_type' => 'application/json'];
|
||||
if ($this->extraAttributes) {
|
||||
$attributes = \array_merge($attributes, $this->extraAttributes);
|
||||
}
|
||||
$this->exchange->publish($data, $routingKey, 0, $attributes);
|
||||
} else {
|
||||
$this->exchange->basic_publish($this->createAmqpMessage($data), $this->exchangeName, $routingKey);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
if ($this->exchange instanceof AMQPExchange) {
|
||||
parent::handleBatch($records);
|
||||
return;
|
||||
}
|
||||
foreach ($records as $record) {
|
||||
if (!$this->isHandling($record)) {
|
||||
continue;
|
||||
}
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
$data = $this->getFormatter()->format($record);
|
||||
$this->exchange->batch_basic_publish($this->createAmqpMessage($data), $this->exchangeName, $this->getRoutingKey($record));
|
||||
}
|
||||
$this->exchange->publish_batch();
|
||||
}
|
||||
/**
|
||||
* Gets the routing key for the AMQP exchange
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
protected function getRoutingKey(array $record) : string
|
||||
{
|
||||
$routingKey = \sprintf('%s.%s', $record['level_name'], $record['channel']);
|
||||
return \strtolower($routingKey);
|
||||
}
|
||||
private function createAmqpMessage(string $data) : AMQPMessage
|
||||
{
|
||||
$attributes = ['delivery_mode' => 2, 'content_type' => 'application/json'];
|
||||
if ($this->extraAttributes) {
|
||||
$attributes = \array_merge($attributes, $this->extraAttributes);
|
||||
}
|
||||
return new AMQPMessage($data, $attributes);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new JsonFormatter(JsonFormatter::BATCH_MODE_JSON, \false);
|
||||
}
|
||||
}
|
||||
252
vendor/Gcp/monolog/monolog/src/Monolog/Handler/BrowserConsoleHandler.php
vendored
Normal file
252
vendor/Gcp/monolog/monolog/src/Monolog/Handler/BrowserConsoleHandler.php
vendored
Normal file
@@ -0,0 +1,252 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use function count;
|
||||
use function headers_list;
|
||||
use function stripos;
|
||||
use function trigger_error;
|
||||
use const E_USER_DEPRECATED;
|
||||
/**
|
||||
* Handler sending logs to browser's javascript console with no browser extension required
|
||||
*
|
||||
* @author Olivier Poitrey <rs@dailymotion.com>
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class BrowserConsoleHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var bool */
|
||||
protected static $initialized = \false;
|
||||
/** @var FormattedRecord[] */
|
||||
protected static $records = [];
|
||||
protected const FORMAT_HTML = 'html';
|
||||
protected const FORMAT_JS = 'js';
|
||||
protected const FORMAT_UNKNOWN = 'unknown';
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* Formatted output may contain some formatting markers to be transferred to `console.log` using the %c format.
|
||||
*
|
||||
* Example of formatted string:
|
||||
*
|
||||
* You can do [[blue text]]{color: blue} or [[green background]]{background-color: green; color: white}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter('[[%channel%]]{macro: autolabel} [[%level_name%]]{font-weight: bold} %message%');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
// Accumulate records
|
||||
static::$records[] = $record;
|
||||
// Register shutdown handler if not already done
|
||||
if (!static::$initialized) {
|
||||
static::$initialized = \true;
|
||||
$this->registerShutdownFunction();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* 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
|
||||
{
|
||||
$format = static::getResponseFormat();
|
||||
if ($format === self::FORMAT_UNKNOWN) {
|
||||
return;
|
||||
}
|
||||
if (count(static::$records)) {
|
||||
if ($format === self::FORMAT_HTML) {
|
||||
static::writeOutput('<script>' . static::generateScript() . '</script>');
|
||||
} elseif ($format === self::FORMAT_JS) {
|
||||
static::writeOutput(static::generateScript());
|
||||
}
|
||||
static::resetStatic();
|
||||
}
|
||||
}
|
||||
public function close() : void
|
||||
{
|
||||
self::resetStatic();
|
||||
}
|
||||
public function reset()
|
||||
{
|
||||
parent::reset();
|
||||
self::resetStatic();
|
||||
}
|
||||
/**
|
||||
* Forget all logged records
|
||||
*/
|
||||
public static function resetStatic() : void
|
||||
{
|
||||
static::$records = [];
|
||||
}
|
||||
/**
|
||||
* Wrapper for register_shutdown_function to allow overriding
|
||||
*/
|
||||
protected function registerShutdownFunction() : void
|
||||
{
|
||||
if (\PHP_SAPI !== 'cli') {
|
||||
\register_shutdown_function(['DeliciousBrains\\WP_Offload_Media\\Gcp\\Monolog\\Handler\\BrowserConsoleHandler', 'send']);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Wrapper for echo to allow overriding
|
||||
*/
|
||||
protected static function writeOutput(string $str) : void
|
||||
{
|
||||
echo $str;
|
||||
}
|
||||
/**
|
||||
* Checks the format of the response
|
||||
*
|
||||
* If Content-Type is set to application/javascript or text/javascript -> js
|
||||
* If Content-Type is set to text/html, or is unset -> html
|
||||
* If Content-Type is anything else -> unknown
|
||||
*
|
||||
* @return string One of 'js', 'html' or 'unknown'
|
||||
* @phpstan-return self::FORMAT_*
|
||||
*/
|
||||
protected static function getResponseFormat() : string
|
||||
{
|
||||
// Check content type
|
||||
foreach (headers_list() as $header) {
|
||||
if (stripos($header, 'content-type:') === 0) {
|
||||
return static::getResponseFormatFromContentType($header);
|
||||
}
|
||||
}
|
||||
return self::FORMAT_HTML;
|
||||
}
|
||||
/**
|
||||
* @return string One of 'js', 'html' or 'unknown'
|
||||
* @phpstan-return self::FORMAT_*
|
||||
*/
|
||||
protected static function getResponseFormatFromContentType(string $contentType) : string
|
||||
{
|
||||
// This handler only works with HTML and javascript outputs
|
||||
// text/javascript is obsolete in favour of application/javascript, but still used
|
||||
if (stripos($contentType, 'application/javascript') !== \false || stripos($contentType, 'text/javascript') !== \false) {
|
||||
return self::FORMAT_JS;
|
||||
}
|
||||
if (stripos($contentType, 'text/html') !== \false) {
|
||||
return self::FORMAT_HTML;
|
||||
}
|
||||
return self::FORMAT_UNKNOWN;
|
||||
}
|
||||
private static function generateScript() : string
|
||||
{
|
||||
$script = [];
|
||||
foreach (static::$records as $record) {
|
||||
$context = static::dump('Context', $record['context']);
|
||||
$extra = static::dump('Extra', $record['extra']);
|
||||
if (empty($context) && empty($extra)) {
|
||||
$script[] = static::call_array(static::getConsoleMethodForLevel($record['level']), static::handleStyles($record['formatted']));
|
||||
} else {
|
||||
$script = \array_merge($script, [static::call_array('groupCollapsed', static::handleStyles($record['formatted']))], $context, $extra, [static::call('groupEnd')]);
|
||||
}
|
||||
}
|
||||
return "(function (c) {if (c && c.groupCollapsed) {\n" . \implode("\n", $script) . "\n}})(console);";
|
||||
}
|
||||
private static function getConsoleMethodForLevel(int $level) : string
|
||||
{
|
||||
return [Logger::DEBUG => 'debug', Logger::INFO => 'info', Logger::NOTICE => 'info', Logger::WARNING => 'warn', Logger::ERROR => 'error', Logger::CRITICAL => 'error', Logger::ALERT => 'error', Logger::EMERGENCY => 'error'][$level] ?? 'log';
|
||||
}
|
||||
/**
|
||||
* @return string[]
|
||||
*/
|
||||
private static function handleStyles(string $formatted) : array
|
||||
{
|
||||
$args = [];
|
||||
$format = '%c' . $formatted;
|
||||
\preg_match_all('/\\[\\[(.*?)\\]\\]\\{([^}]*)\\}/s', $format, $matches, \PREG_OFFSET_CAPTURE | \PREG_SET_ORDER);
|
||||
foreach (\array_reverse($matches) as $match) {
|
||||
$args[] = '"font-weight: normal"';
|
||||
$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]));
|
||||
}
|
||||
$args[] = static::quote('font-weight: normal');
|
||||
$args[] = static::quote($format);
|
||||
return \array_reverse($args);
|
||||
}
|
||||
private static function handleCustomStyles(string $style, string $string) : string
|
||||
{
|
||||
static $colors = ['blue', 'green', 'red', 'magenta', 'orange', 'black', 'grey'];
|
||||
static $labels = [];
|
||||
$style = \preg_replace_callback('/macro\\s*:(.*?)(?:;|$)/', function (array $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])) {
|
||||
$labels[$string] = $colors[count($labels) % count($colors)];
|
||||
}
|
||||
$color = $labels[$string];
|
||||
return "background-color: {$color}; color: white; border-radius: 3px; padding: 0 2px 0 2px";
|
||||
}
|
||||
return $m[1];
|
||||
}, $style);
|
||||
if (null === $style) {
|
||||
$pcreErrorCode = \preg_last_error();
|
||||
throw new \RuntimeException('Failed to run preg_replace_callback: ' . $pcreErrorCode . ' / ' . Utils::pcreLastErrorMessage($pcreErrorCode));
|
||||
}
|
||||
return $style;
|
||||
}
|
||||
/**
|
||||
* @param mixed[] $dict
|
||||
* @return mixed[]
|
||||
*/
|
||||
private static function dump(string $title, array $dict) : array
|
||||
{
|
||||
$script = [];
|
||||
$dict = \array_filter($dict);
|
||||
if (empty($dict)) {
|
||||
return $script;
|
||||
}
|
||||
$script[] = static::call('log', static::quote('%c%s'), static::quote('font-weight: bold'), static::quote($title));
|
||||
foreach ($dict as $key => $value) {
|
||||
$value = \json_encode($value);
|
||||
if (empty($value)) {
|
||||
$value = static::quote('');
|
||||
}
|
||||
$script[] = static::call('log', static::quote('%s: %o'), static::quote((string) $key), $value);
|
||||
}
|
||||
return $script;
|
||||
}
|
||||
private static function quote(string $arg) : string
|
||||
{
|
||||
return '"' . \addcslashes($arg, "\"\n\\") . '"';
|
||||
}
|
||||
/**
|
||||
* @param mixed $args
|
||||
*/
|
||||
private static function call(...$args) : string
|
||||
{
|
||||
$method = \array_shift($args);
|
||||
if (!\is_string($method)) {
|
||||
throw new \UnexpectedValueException('Expected the first arg to be a string, got: ' . \var_export($method, \true));
|
||||
}
|
||||
return static::call_array($method, $args);
|
||||
}
|
||||
/**
|
||||
* @param mixed[] $args
|
||||
*/
|
||||
private static function call_array(string $method, array $args) : string
|
||||
{
|
||||
return 'c.' . $method . '(' . \implode(', ', $args) . ');';
|
||||
}
|
||||
}
|
||||
143
vendor/Gcp/monolog/monolog/src/Monolog/Handler/BufferHandler.php
vendored
Normal file
143
vendor/Gcp/monolog/monolog/src/Monolog/Handler/BufferHandler.php
vendored
Normal file
@@ -0,0 +1,143 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\ResettableInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Buffers all records until closing the handler and then pass them as batch.
|
||||
*
|
||||
* This is useful for a MailHandler to send only one mail per request instead of
|
||||
* sending one per log message.
|
||||
*
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class BufferHandler extends AbstractHandler implements ProcessableHandlerInterface, FormattableHandlerInterface
|
||||
{
|
||||
use ProcessableHandlerTrait;
|
||||
/** @var HandlerInterface */
|
||||
protected $handler;
|
||||
/** @var int */
|
||||
protected $bufferSize = 0;
|
||||
/** @var int */
|
||||
protected $bufferLimit;
|
||||
/** @var bool */
|
||||
protected $flushOnOverflow;
|
||||
/** @var Record[] */
|
||||
protected $buffer = [];
|
||||
/** @var bool */
|
||||
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 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)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->handler = $handler;
|
||||
$this->bufferLimit = $bufferLimit;
|
||||
$this->flushOnOverflow = $flushOnOverflow;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($record['level'] < $this->level) {
|
||||
return \false;
|
||||
}
|
||||
if (!$this->initialized) {
|
||||
// __destructor() doesn't get called on Fatal errors
|
||||
\register_shutdown_function([$this, 'close']);
|
||||
$this->initialized = \true;
|
||||
}
|
||||
if ($this->bufferLimit > 0 && $this->bufferSize === $this->bufferLimit) {
|
||||
if ($this->flushOnOverflow) {
|
||||
$this->flush();
|
||||
} else {
|
||||
\array_shift($this->buffer);
|
||||
$this->bufferSize--;
|
||||
}
|
||||
}
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
$this->buffer[] = $record;
|
||||
$this->bufferSize++;
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
public function flush() : void
|
||||
{
|
||||
if ($this->bufferSize === 0) {
|
||||
return;
|
||||
}
|
||||
$this->handler->handleBatch($this->buffer);
|
||||
$this->clear();
|
||||
}
|
||||
public function __destruct()
|
||||
{
|
||||
// suppress the parent behavior since we already have register_shutdown_function()
|
||||
// to call close(), and the reference contained there will prevent this from being
|
||||
// GC'd until the end of the request
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
$this->flush();
|
||||
$this->handler->close();
|
||||
}
|
||||
/**
|
||||
* Clears the buffer without flushing any messages down to the wrapped handler.
|
||||
*/
|
||||
public function clear() : void
|
||||
{
|
||||
$this->bufferSize = 0;
|
||||
$this->buffer = [];
|
||||
}
|
||||
public function reset()
|
||||
{
|
||||
$this->flush();
|
||||
parent::reset();
|
||||
$this->resetProcessors();
|
||||
if ($this->handler instanceof ResettableInterface) {
|
||||
$this->handler->reset();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
if ($this->handler instanceof FormattableHandlerInterface) {
|
||||
$this->handler->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($this->handler) . ' does not support formatters.');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
if ($this->handler instanceof FormattableHandlerInterface) {
|
||||
return $this->handler->getFormatter();
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($this->handler) . ' does not support formatters.');
|
||||
}
|
||||
}
|
||||
157
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ChromePHPHandler.php
vendored
Normal file
157
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ChromePHPHandler.php
vendored
Normal file
@@ -0,0 +1,157 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\ChromePHPFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Handler sending logs to the ChromePHP extension (http://www.chromephp.com/)
|
||||
*
|
||||
* This also works out of the box with Firefox 43+
|
||||
*
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class ChromePHPHandler extends AbstractProcessingHandler
|
||||
{
|
||||
use WebRequestRecognizerTrait;
|
||||
/**
|
||||
* Version of the extension
|
||||
*/
|
||||
protected const VERSION = '4.0';
|
||||
/**
|
||||
* Header name
|
||||
*/
|
||||
protected 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}';
|
||||
/** @var bool */
|
||||
protected static $initialized = \false;
|
||||
/**
|
||||
* Tracks whether we sent too much data
|
||||
*
|
||||
* Chrome limits the headers to 4KB, so when we sent 3KB we stop sending
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
protected static $overflowed = \false;
|
||||
/** @var mixed[] */
|
||||
protected static $json = ['version' => self::VERSION, 'columns' => ['label', 'log', 'backtrace', 'type'], 'rows' => []];
|
||||
/** @var bool */
|
||||
protected static $sendHeaders = \true;
|
||||
public function __construct($level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
if (!\function_exists('json_encode')) {
|
||||
throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s ChromePHPHandler');
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
if (!$this->isWebRequest()) {
|
||||
return;
|
||||
}
|
||||
$messages = [];
|
||||
foreach ($records as $record) {
|
||||
if ($record['level'] < $this->level) {
|
||||
continue;
|
||||
}
|
||||
/** @var Record $message */
|
||||
$message = $this->processRecord($record);
|
||||
$messages[] = $message;
|
||||
}
|
||||
if (!empty($messages)) {
|
||||
$messages = $this->getFormatter()->formatBatch($messages);
|
||||
self::$json['rows'] = \array_merge(self::$json['rows'], $messages);
|
||||
$this->send();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new ChromePHPFormatter();
|
||||
}
|
||||
/**
|
||||
* Creates & sends header for a record
|
||||
*
|
||||
* @see sendHeader()
|
||||
* @see send()
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!$this->isWebRequest()) {
|
||||
return;
|
||||
}
|
||||
self::$json['rows'][] = $record['formatted'];
|
||||
$this->send();
|
||||
}
|
||||
/**
|
||||
* Sends the log header
|
||||
*
|
||||
* @see sendHeader()
|
||||
*/
|
||||
protected function send() : void
|
||||
{
|
||||
if (self::$overflowed || !self::$sendHeaders) {
|
||||
return;
|
||||
}
|
||||
if (!self::$initialized) {
|
||||
self::$initialized = \true;
|
||||
self::$sendHeaders = $this->headersAccepted();
|
||||
if (!self::$sendHeaders) {
|
||||
return;
|
||||
}
|
||||
self::$json['request_uri'] = $_SERVER['REQUEST_URI'] ?? '';
|
||||
}
|
||||
$json = Utils::jsonEncode(self::$json, Utils::DEFAULT_JSON_FLAGS & ~\JSON_UNESCAPED_UNICODE, \true);
|
||||
$data = \base64_encode($json);
|
||||
if (\strlen($data) > 3 * 1024) {
|
||||
self::$overflowed = \true;
|
||||
$record = ['message' => 'Incomplete logs, chrome header size limit reached', 'context' => [], 'level' => Logger::WARNING, 'level_name' => Logger::getLevelName(Logger::WARNING), 'channel' => 'monolog', 'datetime' => new \DateTimeImmutable(), 'extra' => []];
|
||||
self::$json['rows'][\count(self::$json['rows']) - 1] = $this->getFormatter()->format($record);
|
||||
$json = Utils::jsonEncode(self::$json, Utils::DEFAULT_JSON_FLAGS & ~\JSON_UNESCAPED_UNICODE, \true);
|
||||
$data = \base64_encode($json);
|
||||
}
|
||||
if (\trim($data) !== '') {
|
||||
$this->sendHeader(static::HEADER_NAME, $data);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Send header string to the client
|
||||
*/
|
||||
protected function sendHeader(string $header, string $content) : void
|
||||
{
|
||||
if (!\headers_sent() && self::$sendHeaders) {
|
||||
\header(\sprintf('%s: %s', $header, $content));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Verifies if the headers are accepted by the current user agent
|
||||
*/
|
||||
protected function headersAccepted() : bool
|
||||
{
|
||||
if (empty($_SERVER['HTTP_USER_AGENT'])) {
|
||||
return \false;
|
||||
}
|
||||
return \preg_match(static::USER_AGENT_REGEX, $_SERVER['HTTP_USER_AGENT']) === 1;
|
||||
}
|
||||
}
|
||||
56
vendor/Gcp/monolog/monolog/src/Monolog/Handler/CouchDBHandler.php
vendored
Normal file
56
vendor/Gcp/monolog/monolog/src/Monolog/Handler/CouchDBHandler.php
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\JsonFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* CouchDB handler
|
||||
*
|
||||
* @author Markus Bachmann <markus.bachmann@bachi.biz>
|
||||
*/
|
||||
class CouchDBHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var mixed[] */
|
||||
private $options;
|
||||
/**
|
||||
* @param mixed[] $options
|
||||
*/
|
||||
public function __construct(array $options = [], $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
$this->options = \array_merge(['host' => 'localhost', 'port' => 5984, 'dbname' => 'logger', 'username' => null, 'password' => null], $options);
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$basicAuth = null;
|
||||
if ($this->options['username']) {
|
||||
$basicAuth = \sprintf('%s:%s@', $this->options['username'], $this->options['password']);
|
||||
}
|
||||
$url = 'http://' . $basicAuth . $this->options['host'] . ':' . $this->options['port'] . '/' . $this->options['dbname'];
|
||||
$context = \stream_context_create(['http' => ['method' => 'POST', 'content' => $record['formatted'], 'ignore_errors' => \true, 'max_redirects' => 0, 'header' => 'Content-type: application/json']]);
|
||||
if (\false === @\file_get_contents($url, \false, $context)) {
|
||||
throw new \RuntimeException(\sprintf('Could not connect to %s', $url));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new JsonFormatter(JsonFormatter::BATCH_MODE_JSON, \false);
|
||||
}
|
||||
}
|
||||
138
vendor/Gcp/monolog/monolog/src/Monolog/Handler/CubeHandler.php
vendored
Normal file
138
vendor/Gcp/monolog/monolog/src/Monolog/Handler/CubeHandler.php
vendored
Normal file
@@ -0,0 +1,138 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Logs to Cube.
|
||||
*
|
||||
* @link https://github.com/square/cube/wiki
|
||||
* @author Wan Chen <kami@kamisama.me>
|
||||
* @deprecated Since 2.8.0 and 3.2.0, Cube appears abandoned and thus we will drop this handler in Monolog 4
|
||||
*/
|
||||
class CubeHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var resource|\Socket|null */
|
||||
private $udpConnection = null;
|
||||
/** @var resource|\CurlHandle|null */
|
||||
private $httpConnection = null;
|
||||
/** @var string */
|
||||
private $scheme;
|
||||
/** @var string */
|
||||
private $host;
|
||||
/** @var int */
|
||||
private $port;
|
||||
/** @var string[] */
|
||||
private $acceptedSchemes = ['http', 'udp'];
|
||||
/**
|
||||
* Create a Cube handler
|
||||
*
|
||||
* @throws \UnexpectedValueException when given url is not a valid url.
|
||||
* 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)
|
||||
{
|
||||
$urlInfo = \parse_url($url);
|
||||
if ($urlInfo === \false || !isset($urlInfo['scheme'], $urlInfo['host'], $urlInfo['port'])) {
|
||||
throw new \UnexpectedValueException('URL "' . $url . '" is not valid');
|
||||
}
|
||||
if (!\in_array($urlInfo['scheme'], $this->acceptedSchemes)) {
|
||||
throw new \UnexpectedValueException('Invalid protocol (' . $urlInfo['scheme'] . ').' . ' Valid options are ' . \implode(', ', $this->acceptedSchemes));
|
||||
}
|
||||
$this->scheme = $urlInfo['scheme'];
|
||||
$this->host = $urlInfo['host'];
|
||||
$this->port = (int) $urlInfo['port'];
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* Establish a connection to an UDP socket
|
||||
*
|
||||
* @throws \LogicException when unable to connect to the socket
|
||||
* @throws MissingExtensionException when there is no socket extension
|
||||
*/
|
||||
protected function connectUdp() : void
|
||||
{
|
||||
if (!\extension_loaded('sockets')) {
|
||||
throw new MissingExtensionException('The sockets extension is required to use udp URLs with the CubeHandler');
|
||||
}
|
||||
$udpConnection = \socket_create(\AF_INET, \SOCK_DGRAM, 0);
|
||||
if (\false === $udpConnection) {
|
||||
throw new \LogicException('Unable to create a socket');
|
||||
}
|
||||
$this->udpConnection = $udpConnection;
|
||||
if (!\socket_connect($this->udpConnection, $this->host, $this->port)) {
|
||||
throw new \LogicException('Unable to connect to the socket at ' . $this->host . ':' . $this->port);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Establish a connection to an http server
|
||||
*
|
||||
* @throws \LogicException when unable to connect to the socket
|
||||
* @throws MissingExtensionException when no curl extension
|
||||
*/
|
||||
protected function connectHttp() : void
|
||||
{
|
||||
if (!\extension_loaded('curl')) {
|
||||
throw new MissingExtensionException('The curl extension is required to use http URLs with the CubeHandler');
|
||||
}
|
||||
$httpConnection = \curl_init('http://' . $this->host . ':' . $this->port . '/1.0/event/put');
|
||||
if (\false === $httpConnection) {
|
||||
throw new \LogicException('Unable to connect to ' . $this->host . ':' . $this->port);
|
||||
}
|
||||
$this->httpConnection = $httpConnection;
|
||||
\curl_setopt($this->httpConnection, \CURLOPT_CUSTOMREQUEST, "POST");
|
||||
\curl_setopt($this->httpConnection, \CURLOPT_RETURNTRANSFER, \true);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$date = $record['datetime'];
|
||||
$data = ['time' => $date->format('Y-m-d\\TH:i:s.uO')];
|
||||
unset($record['datetime']);
|
||||
if (isset($record['context']['type'])) {
|
||||
$data['type'] = $record['context']['type'];
|
||||
unset($record['context']['type']);
|
||||
} else {
|
||||
$data['type'] = $record['channel'];
|
||||
}
|
||||
$data['data'] = $record['context'];
|
||||
$data['data']['level'] = $record['level'];
|
||||
if ($this->scheme === 'http') {
|
||||
$this->writeHttp(Utils::jsonEncode($data));
|
||||
} else {
|
||||
$this->writeUdp(Utils::jsonEncode($data));
|
||||
}
|
||||
}
|
||||
private function writeUdp(string $data) : void
|
||||
{
|
||||
if (!$this->udpConnection) {
|
||||
$this->connectUdp();
|
||||
}
|
||||
\socket_send($this->udpConnection, $data, \strlen($data), 0);
|
||||
}
|
||||
private function writeHttp(string $data) : void
|
||||
{
|
||||
if (!$this->httpConnection) {
|
||||
$this->connectHttp();
|
||||
}
|
||||
if (null === $this->httpConnection) {
|
||||
throw new \LogicException('No connection could be established');
|
||||
}
|
||||
\curl_setopt($this->httpConnection, \CURLOPT_POSTFIELDS, '[' . $data . ']');
|
||||
\curl_setopt($this->httpConnection, \CURLOPT_HTTPHEADER, ['Content-Type: application/json', 'Content-Length: ' . \strlen('[' . $data . ']')]);
|
||||
Curl\Util::execute($this->httpConnection, 5, \false);
|
||||
}
|
||||
}
|
||||
54
vendor/Gcp/monolog/monolog/src/Monolog/Handler/Curl/Util.php
vendored
Normal file
54
vendor/Gcp/monolog/monolog/src/Monolog/Handler/Curl/Util.php
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\Curl;
|
||||
|
||||
use CurlHandle;
|
||||
/**
|
||||
* This class is marked as internal and it is not under the BC promise of the package.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
final class Util
|
||||
{
|
||||
/** @var array<int> */
|
||||
private static $retriableErrorCodes = [\CURLE_COULDNT_RESOLVE_HOST, \CURLE_COULDNT_CONNECT, \CURLE_HTTP_NOT_FOUND, \CURLE_READ_ERROR, \CURLE_OPERATION_TIMEOUTED, \CURLE_HTTP_POST_ERROR, \CURLE_SSL_CONNECT_ERROR];
|
||||
/**
|
||||
* Executes a CURL request with optional retries and exception on failure
|
||||
*
|
||||
* @param resource|CurlHandle $ch curl handler
|
||||
* @param int $retries
|
||||
* @param bool $closeAfterDone
|
||||
* @return bool|string @see curl_exec
|
||||
*/
|
||||
public static function execute($ch, int $retries = 5, bool $closeAfterDone = \true)
|
||||
{
|
||||
while ($retries--) {
|
||||
$curlResponse = \curl_exec($ch);
|
||||
if ($curlResponse === \false) {
|
||||
$curlErrno = \curl_errno($ch);
|
||||
if (\false === \in_array($curlErrno, self::$retriableErrorCodes, \true) || !$retries) {
|
||||
$curlError = \curl_error($ch);
|
||||
if ($closeAfterDone) {
|
||||
\curl_close($ch);
|
||||
}
|
||||
throw new \RuntimeException(\sprintf('Curl error (code %d): %s', $curlErrno, $curlError));
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if ($closeAfterDone) {
|
||||
\curl_close($ch);
|
||||
}
|
||||
return $curlResponse;
|
||||
}
|
||||
return \false;
|
||||
}
|
||||
}
|
||||
157
vendor/Gcp/monolog/monolog/src/Monolog/Handler/DeduplicationHandler.php
vendored
Normal file
157
vendor/Gcp/monolog/monolog/src/Monolog/Handler/DeduplicationHandler.php
vendored
Normal file
@@ -0,0 +1,157 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Simple handler wrapper that deduplicates log records across multiple requests
|
||||
*
|
||||
* It also includes the BufferHandler functionality and will buffer
|
||||
* all messages until the end of the request or flush() is called.
|
||||
*
|
||||
* This works by storing all log records' messages above $deduplicationLevel
|
||||
* to the file specified by $deduplicationStore. When further logs come in at the end of the
|
||||
* request (or when flush() is called), all those above $deduplicationLevel are checked
|
||||
* against the existing stored logs. If they match and the timestamps in the stored log is
|
||||
* not older than $time seconds, the new log record is discarded. If no log record is new, the
|
||||
* whole data set is discarded.
|
||||
*
|
||||
* This is mainly useful in combination with Mail handlers or things like Slack or HipChat handlers
|
||||
* that send messages to people, to avoid spamming with the same message over and over in case of
|
||||
* a major component failure like a database server being down which makes all requests fail in the
|
||||
* same way.
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
*/
|
||||
class DeduplicationHandler extends BufferHandler
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $deduplicationStore;
|
||||
/**
|
||||
* @var Level
|
||||
*/
|
||||
protected $deduplicationLevel;
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
protected $time;
|
||||
/**
|
||||
* @var bool
|
||||
*/
|
||||
private $gc = \false;
|
||||
/**
|
||||
* @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 $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
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $deduplicationLevel
|
||||
*/
|
||||
public function __construct(HandlerInterface $handler, ?string $deduplicationStore = null, $deduplicationLevel = Logger::ERROR, int $time = 60, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($handler, 0, Logger::DEBUG, $bubble, \false);
|
||||
$this->deduplicationStore = $deduplicationStore === null ? \sys_get_temp_dir() . '/monolog-dedup-' . \substr(\md5(__FILE__), 0, 20) . '.log' : $deduplicationStore;
|
||||
$this->deduplicationLevel = Logger::toMonologLevel($deduplicationLevel);
|
||||
$this->time = $time;
|
||||
}
|
||||
public function flush() : void
|
||||
{
|
||||
if ($this->bufferSize === 0) {
|
||||
return;
|
||||
}
|
||||
$passthru = null;
|
||||
foreach ($this->buffer as $record) {
|
||||
if ($record['level'] >= $this->deduplicationLevel) {
|
||||
$passthru = $passthru || !$this->isDuplicate($record);
|
||||
if ($passthru) {
|
||||
$this->appendRecord($record);
|
||||
}
|
||||
}
|
||||
}
|
||||
// default of null is valid as well as if no record matches duplicationLevel we just pass through
|
||||
if ($passthru === \true || $passthru === null) {
|
||||
$this->handler->handleBatch($this->buffer);
|
||||
}
|
||||
$this->clear();
|
||||
if ($this->gc) {
|
||||
$this->collectLogs();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
private function isDuplicate(array $record) : bool
|
||||
{
|
||||
if (!\file_exists($this->deduplicationStore)) {
|
||||
return \false;
|
||||
}
|
||||
$store = \file($this->deduplicationStore, \FILE_IGNORE_NEW_LINES | \FILE_SKIP_EMPTY_LINES);
|
||||
if (!\is_array($store)) {
|
||||
return \false;
|
||||
}
|
||||
$yesterday = \time() - 86400;
|
||||
$timestampValidity = $record['datetime']->getTimestamp() - $this->time;
|
||||
$expectedMessage = \preg_replace('{[\\r\\n].*}', '', $record['message']);
|
||||
for ($i = \count($store) - 1; $i >= 0; $i--) {
|
||||
list($timestamp, $level, $message) = \explode(':', $store[$i], 3);
|
||||
if ($level === $record['level_name'] && $message === $expectedMessage && $timestamp > $timestampValidity) {
|
||||
return \true;
|
||||
}
|
||||
if ($timestamp < $yesterday) {
|
||||
$this->gc = \true;
|
||||
}
|
||||
}
|
||||
return \false;
|
||||
}
|
||||
private function collectLogs() : void
|
||||
{
|
||||
if (!\file_exists($this->deduplicationStore)) {
|
||||
return;
|
||||
}
|
||||
$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 = [];
|
||||
$timestampValidity = \time() - $this->time;
|
||||
while (!\feof($handle)) {
|
||||
$log = \fgets($handle);
|
||||
if ($log && \substr($log, 0, 10) >= $timestampValidity) {
|
||||
$validLogs[] = $log;
|
||||
}
|
||||
}
|
||||
\ftruncate($handle, 0);
|
||||
\rewind($handle);
|
||||
foreach ($validLogs as $log) {
|
||||
\fwrite($handle, $log);
|
||||
}
|
||||
\flock($handle, \LOCK_UN);
|
||||
\fclose($handle);
|
||||
$this->gc = \false;
|
||||
}
|
||||
/**
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
private function appendRecord(array $record) : void
|
||||
{
|
||||
\file_put_contents($this->deduplicationStore, $record['datetime']->getTimestamp() . ':' . $record['level_name'] . ':' . \preg_replace('{[\\r\\n].*}', '', $record['message']) . "\n", \FILE_APPEND);
|
||||
}
|
||||
}
|
||||
43
vendor/Gcp/monolog/monolog/src/Monolog/Handler/DoctrineCouchDBHandler.php
vendored
Normal file
43
vendor/Gcp/monolog/monolog/src/Monolog/Handler/DoctrineCouchDBHandler.php
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\NormalizerFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Doctrine\CouchDB\CouchDBClient;
|
||||
/**
|
||||
* CouchDB handler for Doctrine CouchDB ODM
|
||||
*
|
||||
* @author Markus Bachmann <markus.bachmann@bachi.biz>
|
||||
*/
|
||||
class DoctrineCouchDBHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var CouchDBClient */
|
||||
private $client;
|
||||
public function __construct(CouchDBClient $client, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
$this->client = $client;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->client->postDocument($record['formatted']);
|
||||
}
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new NormalizerFormatter();
|
||||
}
|
||||
}
|
||||
89
vendor/Gcp/monolog/monolog/src/Monolog/Handler/DynamoDbHandler.php
vendored
Normal file
89
vendor/Gcp/monolog/monolog/src/Monolog/Handler/DynamoDbHandler.php
vendored
Normal file
@@ -0,0 +1,89 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Aws\Sdk;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Aws\DynamoDb\DynamoDbClient;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Aws\DynamoDb\Marshaler;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\ScalarFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Amazon DynamoDB handler (http://aws.amazon.com/dynamodb/)
|
||||
*
|
||||
* @link https://github.com/aws/aws-sdk-php/
|
||||
* @author Andrew Lawson <adlawson@gmail.com>
|
||||
*/
|
||||
class DynamoDbHandler extends AbstractProcessingHandler
|
||||
{
|
||||
public const DATE_FORMAT = 'Y-m-d\\TH:i:s.uO';
|
||||
/**
|
||||
* @var DynamoDbClient
|
||||
*/
|
||||
protected $client;
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $table;
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
protected $version;
|
||||
/**
|
||||
* @var Marshaler
|
||||
*/
|
||||
protected $marshaler;
|
||||
public function __construct(DynamoDbClient $client, string $table, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
/** @phpstan-ignore-next-line */
|
||||
if (\defined('Aws\\Sdk::VERSION') && \version_compare(Sdk::VERSION, '3.0', '>=')) {
|
||||
$this->version = 3;
|
||||
$this->marshaler = new Marshaler();
|
||||
} else {
|
||||
$this->version = 2;
|
||||
}
|
||||
$this->client = $client;
|
||||
$this->table = $table;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$filtered = $this->filterEmptyFields($record['formatted']);
|
||||
if ($this->version === 3) {
|
||||
$formatted = $this->marshaler->marshalItem($filtered);
|
||||
} else {
|
||||
/** @phpstan-ignore-next-line */
|
||||
$formatted = $this->client->formatAttributes($filtered);
|
||||
}
|
||||
$this->client->putItem(['TableName' => $this->table, 'Item' => $formatted]);
|
||||
}
|
||||
/**
|
||||
* @param mixed[] $record
|
||||
* @return mixed[]
|
||||
*/
|
||||
protected function filterEmptyFields(array $record) : array
|
||||
{
|
||||
return \array_filter($record, function ($value) {
|
||||
return !empty($value) || \false === $value || 0 === $value;
|
||||
});
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new ScalarFormatter(self::DATE_FORMAT);
|
||||
}
|
||||
}
|
||||
118
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ElasticaHandler.php
vendored
Normal file
118
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ElasticaHandler.php
vendored
Normal file
@@ -0,0 +1,118 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elastica\Document;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\ElasticaFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elastica\Client;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elastica\Exception\ExceptionInterface;
|
||||
/**
|
||||
* Elastic Search handler
|
||||
*
|
||||
* Usage example:
|
||||
*
|
||||
* $client = new \Elastica\Client();
|
||||
* $options = array(
|
||||
* 'index' => 'elastic_index_name',
|
||||
* 'type' => 'elastic_doc_type', Types have been removed in Elastica 7
|
||||
* );
|
||||
* $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 mixed[] Handler config options
|
||||
*/
|
||||
protected $options = [];
|
||||
/**
|
||||
* @param Client $client Elastica Client object
|
||||
* @param mixed[] $options Handler configuration
|
||||
*/
|
||||
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,
|
||||
], $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');
|
||||
}
|
||||
/**
|
||||
* @return mixed[]
|
||||
*/
|
||||
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
|
||||
*
|
||||
* @param Document[] $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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
186
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ElasticsearchHandler.php
vendored
Normal file
186
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ElasticsearchHandler.php
vendored
Normal file
@@ -0,0 +1,186 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elastic\Elasticsearch\Response\Elasticsearch;
|
||||
use Throwable;
|
||||
use RuntimeException;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\ElasticsearchFormatter;
|
||||
use InvalidArgumentException;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elasticsearch\Common\Exceptions\RuntimeException as ElasticsearchRuntimeException;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elasticsearch\Client;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elastic\Elasticsearch\Exception\InvalidArgumentException as ElasticInvalidArgumentException;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Elastic\Elasticsearch\Client as Client8;
|
||||
/**
|
||||
* Elasticsearch handler
|
||||
*
|
||||
* @link https://www.elastic.co/guide/en/elasticsearch/client/php-api/current/index.html
|
||||
*
|
||||
* Simple usage example:
|
||||
*
|
||||
* $client = \Elasticsearch\ClientBuilder::create()
|
||||
* ->setHosts($hosts)
|
||||
* ->build();
|
||||
*
|
||||
* $options = array(
|
||||
* 'index' => 'elastic_index_name',
|
||||
* 'type' => 'elastic_doc_type',
|
||||
* );
|
||||
* $handler = new ElasticsearchHandler($client, $options);
|
||||
* $log = new Logger('application');
|
||||
* $log->pushHandler($handler);
|
||||
*
|
||||
* @author Avtandil Kikabidze <akalongman@gmail.com>
|
||||
*/
|
||||
class ElasticsearchHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* @var Client|Client8
|
||||
*/
|
||||
protected $client;
|
||||
/**
|
||||
* @var mixed[] Handler config options
|
||||
*/
|
||||
protected $options = [];
|
||||
/**
|
||||
* @var bool
|
||||
*/
|
||||
private $needsType;
|
||||
/**
|
||||
* @param Client|Client8 $client Elasticsearch Client object
|
||||
* @param mixed[] $options Handler configuration
|
||||
*/
|
||||
public function __construct($client, array $options = [], $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
if (!$client instanceof Client && !$client instanceof Client8) {
|
||||
throw new \TypeError('Elasticsearch\\Client or Elastic\\Elasticsearch\\Client instance required');
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
$this->client = $client;
|
||||
$this->options = \array_merge([
|
||||
'index' => 'monolog',
|
||||
// Elastic index name
|
||||
'type' => '_doc',
|
||||
// Elastic document type
|
||||
'ignore_error' => \false,
|
||||
], $options);
|
||||
if ($client instanceof Client8 || $client::VERSION[0] === '7') {
|
||||
$this->needsType = \false;
|
||||
// force the type to _doc for ES8/ES7
|
||||
$this->options['type'] = '_doc';
|
||||
} else {
|
||||
$this->needsType = \true;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->bulkSend([$record['formatted']]);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
if ($formatter instanceof ElasticsearchFormatter) {
|
||||
return parent::setFormatter($formatter);
|
||||
}
|
||||
throw new InvalidArgumentException('ElasticsearchHandler is only compatible with ElasticsearchFormatter');
|
||||
}
|
||||
/**
|
||||
* Getter options
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function getOptions() : array
|
||||
{
|
||||
return $this->options;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new ElasticsearchFormatter($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
|
||||
*
|
||||
* @param array[] $records Records + _index/_type keys
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
protected function bulkSend(array $records) : void
|
||||
{
|
||||
try {
|
||||
$params = ['body' => []];
|
||||
foreach ($records as $record) {
|
||||
$params['body'][] = ['index' => $this->needsType ? ['_index' => $record['_index'], '_type' => $record['_type']] : ['_index' => $record['_index']]];
|
||||
unset($record['_index'], $record['_type']);
|
||||
$params['body'][] = $record;
|
||||
}
|
||||
/** @var Elasticsearch */
|
||||
$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);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Creates elasticsearch exception from responses array
|
||||
*
|
||||
* Only the first error is converted into an exception.
|
||||
*
|
||||
* @param mixed[]|Elasticsearch $responses returned by $this->client->bulk()
|
||||
*/
|
||||
protected function createExceptionFromResponses($responses) : Throwable
|
||||
{
|
||||
// @phpstan-ignore offsetAccess.nonOffsetAccessible
|
||||
foreach ($responses['items'] ?? [] as $item) {
|
||||
if (isset($item['index']['error'])) {
|
||||
return $this->createExceptionFromError($item['index']['error']);
|
||||
}
|
||||
}
|
||||
if (\class_exists(ElasticInvalidArgumentException::class)) {
|
||||
return new ElasticInvalidArgumentException('Elasticsearch failed to index one or more records.');
|
||||
}
|
||||
return new ElasticsearchRuntimeException('Elasticsearch failed to index one or more records.');
|
||||
}
|
||||
/**
|
||||
* Creates elasticsearch exception from error array
|
||||
*
|
||||
* @param mixed[] $error
|
||||
*/
|
||||
protected function createExceptionFromError(array $error) : Throwable
|
||||
{
|
||||
$previous = isset($error['caused_by']) ? $this->createExceptionFromError($error['caused_by']) : null;
|
||||
if (\class_exists(ElasticInvalidArgumentException::class)) {
|
||||
return new ElasticInvalidArgumentException($error['type'] . ': ' . $error['reason'], 0, $previous);
|
||||
}
|
||||
return new ElasticsearchRuntimeException($error['type'] . ': ' . $error['reason'], 0, $previous);
|
||||
}
|
||||
}
|
||||
77
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ErrorLogHandler.php
vendored
Normal file
77
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ErrorLogHandler.php
vendored
Normal file
@@ -0,0 +1,77 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Stores to PHP error_log() handler.
|
||||
*
|
||||
* @author Elan Ruusamäe <glen@delfi.ee>
|
||||
*/
|
||||
class ErrorLogHandler extends AbstractProcessingHandler
|
||||
{
|
||||
public const OPERATING_SYSTEM = 0;
|
||||
public const SAPI = 4;
|
||||
/** @var int */
|
||||
protected $messageType;
|
||||
/** @var bool */
|
||||
protected $expandNewlines;
|
||||
/**
|
||||
* @param int $messageType Says where the error should go.
|
||||
* @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)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
if (\false === \in_array($messageType, self::getAvailableTypes(), \true)) {
|
||||
$message = \sprintf('The given message type "%s" is not supported', \print_r($messageType, \true));
|
||||
throw new \InvalidArgumentException($message);
|
||||
}
|
||||
$this->messageType = $messageType;
|
||||
$this->expandNewlines = $expandNewlines;
|
||||
}
|
||||
/**
|
||||
* @return int[] With all available types
|
||||
*/
|
||||
public static function getAvailableTypes() : array
|
||||
{
|
||||
return [self::OPERATING_SYSTEM, self::SAPI];
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter('[%datetime%] %channel%.%level_name%: %message% %context% %extra%');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!$this->expandNewlines) {
|
||||
\error_log((string) $record['formatted'], $this->messageType);
|
||||
return;
|
||||
}
|
||||
$lines = \preg_split('{[\\r\\n]+}', (string) $record['formatted']);
|
||||
if ($lines === \false) {
|
||||
$pcreErrorCode = \preg_last_error();
|
||||
throw new \RuntimeException('Failed to preg_split formatted string: ' . $pcreErrorCode . ' / ' . Utils::pcreLastErrorMessage($pcreErrorCode));
|
||||
}
|
||||
foreach ($lines as $line) {
|
||||
\error_log($line, $this->messageType);
|
||||
}
|
||||
}
|
||||
}
|
||||
67
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FallbackGroupHandler.php
vendored
Normal file
67
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FallbackGroupHandler.php
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use Throwable;
|
||||
/**
|
||||
* Forwards records to at most one handler
|
||||
*
|
||||
* If a handler fails, the exception is suppressed and the record is forwarded to the next handler.
|
||||
*
|
||||
* As soon as one handler handles a record successfully, the handling stops there.
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class FallbackGroupHandler extends GroupHandler
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$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);
|
||||
}
|
||||
/** @var Record[] $records */
|
||||
$records = $processed;
|
||||
}
|
||||
foreach ($this->handlers as $handler) {
|
||||
try {
|
||||
$handler->handleBatch($records);
|
||||
break;
|
||||
} catch (Throwable $e) {
|
||||
// What throwable?
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
187
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FilterHandler.php
vendored
Normal file
187
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FilterHandler.php
vendored
Normal file
@@ -0,0 +1,187 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\ResettableInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Simple handler wrapper that filters records based on a list of levels
|
||||
*
|
||||
* It can be configured with an exact list of levels to allow, or a min/max level.
|
||||
*
|
||||
* @author Hennadiy Verkh
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
class FilterHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface, FormattableHandlerInterface
|
||||
{
|
||||
use ProcessableHandlerTrait;
|
||||
/**
|
||||
* Handler or factory callable($record, $this)
|
||||
*
|
||||
* @var callable|HandlerInterface
|
||||
* @phpstan-var callable(?Record, HandlerInterface): HandlerInterface|HandlerInterface
|
||||
*/
|
||||
protected $handler;
|
||||
/**
|
||||
* Minimum level for logs that are passed to handler
|
||||
*
|
||||
* @var int[]
|
||||
* @phpstan-var array<Level, int>
|
||||
*/
|
||||
protected $acceptedLevels;
|
||||
/**
|
||||
* Whether the messages that are handled can bubble up the stack or not
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
protected $bubble;
|
||||
/**
|
||||
* @psalm-param HandlerInterface|callable(?Record, HandlerInterface): HandlerInterface $handler
|
||||
*
|
||||
* @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 bool $bubble Whether the messages that are handled can bubble up the stack or not
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::*|array<Level|LevelName|LogLevel::*> $minLevelOrList
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $maxLevel
|
||||
*/
|
||||
public function __construct($handler, $minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY, bool $bubble = \true)
|
||||
{
|
||||
$this->handler = $handler;
|
||||
$this->bubble = $bubble;
|
||||
$this->setAcceptedLevels($minLevelOrList, $maxLevel);
|
||||
if (!$this->handler instanceof HandlerInterface && !\is_callable($this->handler)) {
|
||||
throw new \RuntimeException("The given handler (" . \json_encode($this->handler) . ") is not a callable nor a Monolog\\Handler\\HandlerInterface object");
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @phpstan-return array<int, Level>
|
||||
*/
|
||||
public function getAcceptedLevels() : array
|
||||
{
|
||||
return \array_flip($this->acceptedLevels);
|
||||
}
|
||||
/**
|
||||
* @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
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::*|array<Level|LevelName|LogLevel::*> $minLevelOrList
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $maxLevel
|
||||
*/
|
||||
public function setAcceptedLevels($minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY) : self
|
||||
{
|
||||
if (\is_array($minLevelOrList)) {
|
||||
$acceptedLevels = \array_map('DeliciousBrains\\WP_Offload_Media\\Gcp\\Monolog\\Logger::toMonologLevel', $minLevelOrList);
|
||||
} else {
|
||||
$minLevelOrList = Logger::toMonologLevel($minLevelOrList);
|
||||
$maxLevel = Logger::toMonologLevel($maxLevel);
|
||||
$acceptedLevels = \array_values(\array_filter(Logger::getLevels(), function ($level) use($minLevelOrList, $maxLevel) {
|
||||
return $level >= $minLevelOrList && $level <= $maxLevel;
|
||||
}));
|
||||
}
|
||||
$this->acceptedLevels = \array_flip($acceptedLevels);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
return isset($this->acceptedLevels[$record['level']]);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if (!$this->isHandling($record)) {
|
||||
return \false;
|
||||
}
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
$this->getHandler($record)->handle($record);
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
$filtered = [];
|
||||
foreach ($records as $record) {
|
||||
if ($this->isHandling($record)) {
|
||||
$filtered[] = $record;
|
||||
}
|
||||
}
|
||||
if (\count($filtered) > 0) {
|
||||
$this->getHandler($filtered[\count($filtered) - 1])->handleBatch($filtered);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Return the nested handler
|
||||
*
|
||||
* If the handler was provided as a factory callable, this will trigger the handler's instantiation.
|
||||
*
|
||||
* @return HandlerInterface
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
public function getHandler(?array $record = null)
|
||||
{
|
||||
if (!$this->handler instanceof HandlerInterface) {
|
||||
$this->handler = ($this->handler)($record, $this);
|
||||
if (!$this->handler instanceof HandlerInterface) {
|
||||
throw new \RuntimeException("The factory callable should return a HandlerInterface");
|
||||
}
|
||||
}
|
||||
return $this->handler;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
$handler = $this->getHandler();
|
||||
if ($handler instanceof FormattableHandlerInterface) {
|
||||
$handler->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($handler) . ' does not support formatters.');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
$handler = $this->getHandler();
|
||||
if ($handler instanceof FormattableHandlerInterface) {
|
||||
return $handler->getFormatter();
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($handler) . ' does not support formatters.');
|
||||
}
|
||||
public function reset()
|
||||
{
|
||||
$this->resetProcessors();
|
||||
if ($this->getHandler() instanceof ResettableInterface) {
|
||||
$this->getHandler()->reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
29
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.php
vendored
Normal file
29
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.php
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\FingersCrossed;
|
||||
|
||||
/**
|
||||
* Interface for activation strategies for the FingersCrossedHandler.
|
||||
*
|
||||
* @author Johannes M. Schmitt <schmittjoh@gmail.com>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
interface ActivationStrategyInterface
|
||||
{
|
||||
/**
|
||||
* Returns whether the given record activates the handler.
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
public function isHandlerActivated(array $record) : bool;
|
||||
}
|
||||
72
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.php
vendored
Normal file
72
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.php
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\FingersCrossed;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Channel and Error level based monolog activation strategy. Allows to trigger activation
|
||||
* based on level per channel. e.g. trigger activation on level 'ERROR' by default, except
|
||||
* for records of the 'sql' channel; those should trigger activation on level 'WARN'.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* <code>
|
||||
* $activationStrategy = new ChannelLevelActivationStrategy(
|
||||
* Logger::CRITICAL,
|
||||
* array(
|
||||
* 'request' => Logger::ALERT,
|
||||
* 'sensitive' => Logger::ERROR,
|
||||
* )
|
||||
* );
|
||||
* $handler = new FingersCrossedHandler(new StreamHandler('php://stderr'), $activationStrategy);
|
||||
* </code>
|
||||
*
|
||||
* @author Mike Meessen <netmikey@gmail.com>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
class ChannelLevelActivationStrategy implements ActivationStrategyInterface
|
||||
{
|
||||
/**
|
||||
* @var Level
|
||||
*/
|
||||
private $defaultActionLevel;
|
||||
/**
|
||||
* @var array<string, Level>
|
||||
*/
|
||||
private $channelToActionLevel;
|
||||
/**
|
||||
* @param int|string $defaultActionLevel The default action level to be used if the record's category doesn't match any
|
||||
* @param array<string, int> $channelToActionLevel An array that maps channel names to action levels.
|
||||
*
|
||||
* @phpstan-param array<string, Level> $channelToActionLevel
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $defaultActionLevel
|
||||
*/
|
||||
public function __construct($defaultActionLevel, array $channelToActionLevel = [])
|
||||
{
|
||||
$this->defaultActionLevel = Logger::toMonologLevel($defaultActionLevel);
|
||||
$this->channelToActionLevel = \array_map('DeliciousBrains\\WP_Offload_Media\\Gcp\\Monolog\\Logger::toMonologLevel', $channelToActionLevel);
|
||||
}
|
||||
/**
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
public function isHandlerActivated(array $record) : bool
|
||||
{
|
||||
if (isset($this->channelToActionLevel[$record['channel']])) {
|
||||
return $record['level'] >= $this->channelToActionLevel[$record['channel']];
|
||||
}
|
||||
return $record['level'] >= $this->defaultActionLevel;
|
||||
}
|
||||
}
|
||||
43
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.php
vendored
Normal file
43
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.php
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\FingersCrossed;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Error level based activation strategy.
|
||||
*
|
||||
* @author Johannes M. Schmitt <schmittjoh@gmail.com>
|
||||
*
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
class ErrorLevelActivationStrategy implements ActivationStrategyInterface
|
||||
{
|
||||
/**
|
||||
* @var Level
|
||||
*/
|
||||
private $actionLevel;
|
||||
/**
|
||||
* @param int|string $actionLevel Level or name or value
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $actionLevel
|
||||
*/
|
||||
public function __construct($actionLevel)
|
||||
{
|
||||
$this->actionLevel = Logger::toMonologLevel($actionLevel);
|
||||
}
|
||||
public function isHandlerActivated(array $record) : bool
|
||||
{
|
||||
return $record['level'] >= $this->actionLevel;
|
||||
}
|
||||
}
|
||||
224
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossedHandler.php
vendored
Normal file
224
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FingersCrossedHandler.php
vendored
Normal file
@@ -0,0 +1,224 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\FingersCrossed\ErrorLevelActivationStrategy;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\FingersCrossed\ActivationStrategyInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\ResettableInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Buffers all records until a certain level is reached
|
||||
*
|
||||
* The advantage of this approach is that you don't get any clutter in your log files.
|
||||
* 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>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
class FingersCrossedHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface, FormattableHandlerInterface
|
||||
{
|
||||
use ProcessableHandlerTrait;
|
||||
/**
|
||||
* @var callable|HandlerInterface
|
||||
* @phpstan-var callable(?Record, HandlerInterface): HandlerInterface|HandlerInterface
|
||||
*/
|
||||
protected $handler;
|
||||
/** @var ActivationStrategyInterface */
|
||||
protected $activationStrategy;
|
||||
/** @var bool */
|
||||
protected $buffering = \true;
|
||||
/** @var int */
|
||||
protected $bufferSize;
|
||||
/** @var Record[] */
|
||||
protected $buffer = [];
|
||||
/** @var bool */
|
||||
protected $stopBuffering;
|
||||
/**
|
||||
* @var ?int
|
||||
* @phpstan-var ?Level
|
||||
*/
|
||||
protected $passthruLevel;
|
||||
/** @var bool */
|
||||
protected $bubble;
|
||||
/**
|
||||
* @psalm-param HandlerInterface|callable(?Record, HandlerInterface): HandlerInterface $handler
|
||||
*
|
||||
* @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
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $passthruLevel
|
||||
* @phpstan-param Level|LevelName|LogLevel::*|ActivationStrategyInterface $activationStrategy
|
||||
*/
|
||||
public function __construct($handler, $activationStrategy = null, int $bufferSize = 0, bool $bubble = \true, bool $stopBuffering = \true, $passthruLevel = null)
|
||||
{
|
||||
if (null === $activationStrategy) {
|
||||
$activationStrategy = new ErrorLevelActivationStrategy(Logger::WARNING);
|
||||
}
|
||||
// convert simple int activationStrategy to an object
|
||||
if (!$activationStrategy instanceof ActivationStrategyInterface) {
|
||||
$activationStrategy = new ErrorLevelActivationStrategy($activationStrategy);
|
||||
}
|
||||
$this->handler = $handler;
|
||||
$this->activationStrategy = $activationStrategy;
|
||||
$this->bufferSize = $bufferSize;
|
||||
$this->bubble = $bubble;
|
||||
$this->stopBuffering = $stopBuffering;
|
||||
if ($passthruLevel !== null) {
|
||||
$this->passthruLevel = Logger::toMonologLevel($passthruLevel);
|
||||
}
|
||||
if (!$this->handler instanceof HandlerInterface && !\is_callable($this->handler)) {
|
||||
throw new \RuntimeException("The given handler (" . \json_encode($this->handler) . ") is not a callable nor a Monolog\\Handler\\HandlerInterface object");
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
return \true;
|
||||
}
|
||||
/**
|
||||
* Manually activate this logger regardless of the activation strategy
|
||||
*/
|
||||
public function activate() : void
|
||||
{
|
||||
if ($this->stopBuffering) {
|
||||
$this->buffering = \false;
|
||||
}
|
||||
$this->getHandler(\end($this->buffer) ?: null)->handleBatch($this->buffer);
|
||||
$this->buffer = [];
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
if ($this->buffering) {
|
||||
$this->buffer[] = $record;
|
||||
if ($this->bufferSize > 0 && \count($this->buffer) > $this->bufferSize) {
|
||||
\array_shift($this->buffer);
|
||||
}
|
||||
if ($this->activationStrategy->isHandlerActivated($record)) {
|
||||
$this->activate();
|
||||
}
|
||||
} else {
|
||||
$this->getHandler($record)->handle($record);
|
||||
}
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
$this->flushBuffer();
|
||||
$this->getHandler()->close();
|
||||
}
|
||||
public function reset()
|
||||
{
|
||||
$this->flushBuffer();
|
||||
$this->resetProcessors();
|
||||
if ($this->getHandler() instanceof ResettableInterface) {
|
||||
$this->getHandler()->reset();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Clears the buffer without flushing any messages down to the wrapped handler.
|
||||
*
|
||||
* It also resets the handler to its initial buffering state.
|
||||
*/
|
||||
public function clear() : void
|
||||
{
|
||||
$this->buffer = [];
|
||||
$this->reset();
|
||||
}
|
||||
/**
|
||||
* Resets the state of the handler. Stops forwarding records to the wrapped handler.
|
||||
*/
|
||||
private function flushBuffer() : void
|
||||
{
|
||||
if (null !== $this->passthruLevel) {
|
||||
$level = $this->passthruLevel;
|
||||
$this->buffer = \array_filter($this->buffer, function ($record) use($level) {
|
||||
return $record['level'] >= $level;
|
||||
});
|
||||
if (\count($this->buffer) > 0) {
|
||||
$this->getHandler(\end($this->buffer))->handleBatch($this->buffer);
|
||||
}
|
||||
}
|
||||
$this->buffer = [];
|
||||
$this->buffering = \true;
|
||||
}
|
||||
/**
|
||||
* Return the nested handler
|
||||
*
|
||||
* If the handler was provided as a factory callable, this will trigger the handler's instantiation.
|
||||
*
|
||||
* @return HandlerInterface
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
public function getHandler(?array $record = null)
|
||||
{
|
||||
if (!$this->handler instanceof HandlerInterface) {
|
||||
$this->handler = ($this->handler)($record, $this);
|
||||
if (!$this->handler instanceof HandlerInterface) {
|
||||
throw new \RuntimeException("The factory callable should return a HandlerInterface");
|
||||
}
|
||||
}
|
||||
return $this->handler;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
$handler = $this->getHandler();
|
||||
if ($handler instanceof FormattableHandlerInterface) {
|
||||
$handler->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($handler) . ' does not support formatters.');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
$handler = $this->getHandler();
|
||||
if ($handler instanceof FormattableHandlerInterface) {
|
||||
return $handler->getFormatter();
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($handler) . ' does not support formatters.');
|
||||
}
|
||||
}
|
||||
152
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FirePHPHandler.php
vendored
Normal file
152
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FirePHPHandler.php
vendored
Normal file
@@ -0,0 +1,152 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\WildfireFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Simple FirePHP Handler (http://www.firephp.org/), which uses the Wildfire protocol.
|
||||
*
|
||||
* @author Eric Clemmons (@ericclemmons) <eric@uxdriven.com>
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class FirePHPHandler extends AbstractProcessingHandler
|
||||
{
|
||||
use WebRequestRecognizerTrait;
|
||||
/**
|
||||
* WildFire JSON header message format
|
||||
*/
|
||||
protected 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';
|
||||
/**
|
||||
* 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';
|
||||
/**
|
||||
* Header prefix for Wildfire to recognize & parse headers
|
||||
*/
|
||||
protected const HEADER_PREFIX = 'X-Wf';
|
||||
/**
|
||||
* Whether or not Wildfire vendor-specific headers have been generated & sent yet
|
||||
* @var bool
|
||||
*/
|
||||
protected static $initialized = \false;
|
||||
/**
|
||||
* Shared static message index between potentially multiple handlers
|
||||
* @var int
|
||||
*/
|
||||
protected static $messageIndex = 1;
|
||||
/** @var bool */
|
||||
protected static $sendHeaders = \true;
|
||||
/**
|
||||
* Base header creation function used by init headers & record headers
|
||||
*
|
||||
* @param array<int|string> $meta Wildfire Plugin, Protocol & Structure Indexes
|
||||
* @param string $message Log message
|
||||
*
|
||||
* @return array<string, string> Complete header string ready for the client as key and message as value
|
||||
*
|
||||
* @phpstan-return non-empty-array<string, string>
|
||||
*/
|
||||
protected function createHeader(array $meta, string $message) : array
|
||||
{
|
||||
$header = \sprintf('%s-%s', static::HEADER_PREFIX, \join('-', $meta));
|
||||
return [$header => $message];
|
||||
}
|
||||
/**
|
||||
* Creates message header from record
|
||||
*
|
||||
* @return array<string, string>
|
||||
*
|
||||
* @phpstan-return non-empty-array<string, string>
|
||||
*
|
||||
* @see createHeader()
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
protected function createRecordHeader(array $record) : array
|
||||
{
|
||||
// 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++], $record['formatted']);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new WildfireFormatter();
|
||||
}
|
||||
/**
|
||||
* Wildfire initialization headers to enable message parsing
|
||||
*
|
||||
* @see createHeader()
|
||||
* @see sendHeader()
|
||||
*
|
||||
* @return array<string, string>
|
||||
*/
|
||||
protected function getInitHeaders() : array
|
||||
{
|
||||
// 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));
|
||||
}
|
||||
/**
|
||||
* Send header string to the client
|
||||
*/
|
||||
protected function sendHeader(string $header, string $content) : void
|
||||
{
|
||||
if (!\headers_sent() && self::$sendHeaders) {
|
||||
\header(\sprintf('%s: %s', $header, $content));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Creates & sends header for a record, ensuring init headers have been sent prior
|
||||
*
|
||||
* @see sendHeader()
|
||||
* @see sendInitHeaders()
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!self::$sendHeaders || !$this->isWebRequest()) {
|
||||
return;
|
||||
}
|
||||
// WildFire-specific headers must be sent prior to any messages
|
||||
if (!self::$initialized) {
|
||||
self::$initialized = \true;
|
||||
self::$sendHeaders = $this->headersAccepted();
|
||||
if (!self::$sendHeaders) {
|
||||
return;
|
||||
}
|
||||
foreach ($this->getInitHeaders() as $header => $content) {
|
||||
$this->sendHeader($header, $content);
|
||||
}
|
||||
}
|
||||
$header = $this->createRecordHeader($record);
|
||||
if (\trim(\current($header)) !== '') {
|
||||
$this->sendHeader(\key($header), \current($header));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Verifies if the headers are accepted by the current user agent
|
||||
*/
|
||||
protected function headersAccepted() : bool
|
||||
{
|
||||
if (!empty($_SERVER['HTTP_USER_AGENT']) && \preg_match('{\\bFirePHP/\\d+\\.\\d+\\b}', $_SERVER['HTTP_USER_AGENT'])) {
|
||||
return \true;
|
||||
}
|
||||
return isset($_SERVER['HTTP_X_FIREPHP_VERSION']);
|
||||
}
|
||||
}
|
||||
102
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FleepHookHandler.php
vendored
Normal file
102
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FleepHookHandler.php
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Sends logs to Fleep.io using Webhook integrations
|
||||
*
|
||||
* You'll need a Fleep.io account to use this handler.
|
||||
*
|
||||
* @see https://fleep.io/integrations/webhooks/ Fleep Webhooks Documentation
|
||||
* @author Ando Roots <ando@sqroot.eu>
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class FleepHookHandler extends SocketHandler
|
||||
{
|
||||
protected const FLEEP_HOST = 'fleep.io';
|
||||
protected const FLEEP_HOOK_URI = '/hook/';
|
||||
/**
|
||||
* @var string Webhook token (specifies the conversation where logs are sent)
|
||||
*/
|
||||
protected $token;
|
||||
/**
|
||||
* Construct a new Fleep.io Handler.
|
||||
*
|
||||
* For instructions on how to create a new web hook in your conversations
|
||||
* see https://fleep.io/integrations/webhooks/
|
||||
*
|
||||
* @param string $token Webhook token
|
||||
* @throws MissingExtensionException
|
||||
*/
|
||||
public function __construct(string $token, $level = Logger::DEBUG, bool $bubble = \true, bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
if (!\extension_loaded('openssl')) {
|
||||
throw new MissingExtensionException('The OpenSSL PHP extension is required to use the FleepHookHandler');
|
||||
}
|
||||
$this->token = $token;
|
||||
$connectionString = 'ssl://' . static::FLEEP_HOST . ':443';
|
||||
parent::__construct($connectionString, $level, $bubble, $persistent, $timeout, $writingTimeout, $connectionTimeout, $chunkSize);
|
||||
}
|
||||
/**
|
||||
* Returns the default formatter to use with this handler
|
||||
*
|
||||
* Overloaded to remove empty context and extra arrays from the end of the log message.
|
||||
*
|
||||
* @return LineFormatter
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter(null, null, \true, \true);
|
||||
}
|
||||
/**
|
||||
* Handles a log record
|
||||
*/
|
||||
public function write(array $record) : void
|
||||
{
|
||||
parent::write($record);
|
||||
$this->closeSocket();
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
$content = $this->buildContent($record);
|
||||
return $this->buildHeader($content) . $content;
|
||||
}
|
||||
/**
|
||||
* Builds the header of the API Call
|
||||
*/
|
||||
private function buildHeader(string $content) : string
|
||||
{
|
||||
$header = "POST " . static::FLEEP_HOOK_URI . $this->token . " HTTP/1.1\r\n";
|
||||
$header .= "Host: " . static::FLEEP_HOST . "\r\n";
|
||||
$header .= "Content-Type: application/x-www-form-urlencoded\r\n";
|
||||
$header .= "Content-Length: " . \strlen($content) . "\r\n";
|
||||
$header .= "\r\n";
|
||||
return $header;
|
||||
}
|
||||
/**
|
||||
* Builds the body of API call
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
private function buildContent(array $record) : string
|
||||
{
|
||||
$dataArray = ['message' => $record['formatted']];
|
||||
return \http_build_query($dataArray);
|
||||
}
|
||||
}
|
||||
103
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FlowdockHandler.php
vendored
Normal file
103
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FlowdockHandler.php
vendored
Normal file
@@ -0,0 +1,103 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FlowdockFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Sends notifications through the Flowdock push API
|
||||
*
|
||||
* This must be configured with a FlowdockFormatter instance via setFormatter()
|
||||
*
|
||||
* Notes:
|
||||
* API token - Flowdock API token
|
||||
*
|
||||
* @author Dominik Liebler <liebler.dominik@gmail.com>
|
||||
* @see https://www.flowdock.com/api/push
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
* @deprecated Since 2.9.0 and 3.3.0, Flowdock was shutdown we will thus drop this handler in Monolog 4
|
||||
*/
|
||||
class FlowdockHandler extends SocketHandler
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $apiToken;
|
||||
/**
|
||||
* @throws MissingExtensionException if OpenSSL is missing
|
||||
*/
|
||||
public function __construct(string $apiToken, $level = Logger::DEBUG, bool $bubble = \true, bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
if (!\extension_loaded('openssl')) {
|
||||
throw new MissingExtensionException('The OpenSSL PHP extension is required to use the FlowdockHandler');
|
||||
}
|
||||
parent::__construct('ssl://api.flowdock.com:443', $level, $bubble, $persistent, $timeout, $writingTimeout, $connectionTimeout, $chunkSize);
|
||||
$this->apiToken = $apiToken;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
if (!$formatter instanceof FlowdockFormatter) {
|
||||
throw new \InvalidArgumentException('The FlowdockHandler requires an instance of Monolog\\Formatter\\FlowdockFormatter to function correctly');
|
||||
}
|
||||
return parent::setFormatter($formatter);
|
||||
}
|
||||
/**
|
||||
* Gets the default formatter.
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
throw new \InvalidArgumentException('The FlowdockHandler must be configured (via setFormatter) with an instance of Monolog\\Formatter\\FlowdockFormatter to function correctly');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
parent::write($record);
|
||||
$this->closeSocket();
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
$content = $this->buildContent($record);
|
||||
return $this->buildHeader($content) . $content;
|
||||
}
|
||||
/**
|
||||
* Builds the body of API call
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
private function buildContent(array $record) : string
|
||||
{
|
||||
return Utils::jsonEncode($record['formatted']['flowdock']);
|
||||
}
|
||||
/**
|
||||
* Builds the header of the API Call
|
||||
*/
|
||||
private function buildHeader(string $content) : string
|
||||
{
|
||||
$header = "POST /v1/messages/team_inbox/" . $this->apiToken . " HTTP/1.1\r\n";
|
||||
$header .= "Host: api.flowdock.com\r\n";
|
||||
$header .= "Content-Type: application/json\r\n";
|
||||
$header .= "Content-Length: " . \strlen($content) . "\r\n";
|
||||
$header .= "\r\n";
|
||||
return $header;
|
||||
}
|
||||
}
|
||||
35
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FormattableHandlerInterface.php
vendored
Normal file
35
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FormattableHandlerInterface.php
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Interface to describe loggers that have a formatter
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*/
|
||||
interface FormattableHandlerInterface
|
||||
{
|
||||
/**
|
||||
* Sets the formatter.
|
||||
*
|
||||
* @param FormatterInterface $formatter
|
||||
* @return HandlerInterface self
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface;
|
||||
/**
|
||||
* Gets the formatter.
|
||||
*
|
||||
* @return FormatterInterface
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface;
|
||||
}
|
||||
54
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FormattableHandlerTrait.php
vendored
Normal file
54
vendor/Gcp/monolog/monolog/src/Monolog/Handler/FormattableHandlerTrait.php
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
/**
|
||||
* Helper trait for implementing FormattableInterface
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*/
|
||||
trait FormattableHandlerTrait
|
||||
{
|
||||
/**
|
||||
* @var ?FormatterInterface
|
||||
*/
|
||||
protected $formatter;
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
$this->formatter = $formatter;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
if (!$this->formatter) {
|
||||
$this->formatter = $this->getDefaultFormatter();
|
||||
}
|
||||
return $this->formatter;
|
||||
}
|
||||
/**
|
||||
* Gets the default formatter.
|
||||
*
|
||||
* Overwrite this if the LineFormatter is not a good default for your handler.
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter();
|
||||
}
|
||||
}
|
||||
52
vendor/Gcp/monolog/monolog/src/Monolog/Handler/GelfHandler.php
vendored
Normal file
52
vendor/Gcp/monolog/monolog/src/Monolog/Handler/GelfHandler.php
vendored
Normal file
@@ -0,0 +1,52 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Gelf\PublisherInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\GelfMessageFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Handler to send messages to a Graylog2 (http://www.graylog2.org) server
|
||||
*
|
||||
* @author Matt Lehner <mlehner@gmail.com>
|
||||
* @author Benjamin Zikarsky <benjamin@zikarsky.de>
|
||||
*/
|
||||
class GelfHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* @var PublisherInterface the publisher object that sends the message to the server
|
||||
*/
|
||||
protected $publisher;
|
||||
/**
|
||||
* @param PublisherInterface $publisher a gelf publisher object
|
||||
*/
|
||||
public function __construct(PublisherInterface $publisher, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->publisher = $publisher;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->publisher->publish($record['formatted']);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new GelfMessageFormatter();
|
||||
}
|
||||
}
|
||||
115
vendor/Gcp/monolog/monolog/src/Monolog/Handler/GroupHandler.php
vendored
Normal file
115
vendor/Gcp/monolog/monolog/src/Monolog/Handler/GroupHandler.php
vendored
Normal file
@@ -0,0 +1,115 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\ResettableInterface;
|
||||
/**
|
||||
* Forwards records to multiple handlers
|
||||
*
|
||||
* @author Lenar Lõhmus <lenar@city.ee>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class GroupHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface
|
||||
{
|
||||
use ProcessableHandlerTrait;
|
||||
/** @var HandlerInterface[] */
|
||||
protected $handlers;
|
||||
/** @var bool */
|
||||
protected $bubble;
|
||||
/**
|
||||
* @param HandlerInterface[] $handlers Array of Handlers.
|
||||
* @param bool $bubble Whether the messages that are handled can bubble up the stack or not
|
||||
*/
|
||||
public function __construct(array $handlers, bool $bubble = \true)
|
||||
{
|
||||
foreach ($handlers as $handler) {
|
||||
if (!$handler instanceof HandlerInterface) {
|
||||
throw new \InvalidArgumentException('The first argument of the GroupHandler must be an array of HandlerInterface instances.');
|
||||
}
|
||||
}
|
||||
$this->handlers = $handlers;
|
||||
$this->bubble = $bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
foreach ($this->handlers as $handler) {
|
||||
if ($handler->isHandling($record)) {
|
||||
return \true;
|
||||
}
|
||||
}
|
||||
return \false;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
foreach ($this->handlers as $handler) {
|
||||
$handler->handle($record);
|
||||
}
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
if ($this->processors) {
|
||||
$processed = [];
|
||||
foreach ($records as $record) {
|
||||
$processed[] = $this->processRecord($record);
|
||||
}
|
||||
/** @var Record[] $records */
|
||||
$records = $processed;
|
||||
}
|
||||
foreach ($this->handlers as $handler) {
|
||||
$handler->handleBatch($records);
|
||||
}
|
||||
}
|
||||
public function reset()
|
||||
{
|
||||
$this->resetProcessors();
|
||||
foreach ($this->handlers as $handler) {
|
||||
if ($handler instanceof ResettableInterface) {
|
||||
$handler->reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
public function close() : void
|
||||
{
|
||||
parent::close();
|
||||
foreach ($this->handlers as $handler) {
|
||||
$handler->close();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
foreach ($this->handlers as $handler) {
|
||||
if ($handler instanceof FormattableHandlerInterface) {
|
||||
$handler->setFormatter($formatter);
|
||||
}
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
56
vendor/Gcp/monolog/monolog/src/Monolog/Handler/Handler.php
vendored
Normal file
56
vendor/Gcp/monolog/monolog/src/Monolog/Handler/Handler.php
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
/**
|
||||
* Base Handler class providing basic close() support as well as handleBatch
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*/
|
||||
abstract class Handler implements HandlerInterface
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
foreach ($records as $record) {
|
||||
$this->handle($record);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
}
|
||||
public function __destruct()
|
||||
{
|
||||
try {
|
||||
$this->close();
|
||||
} catch (\Throwable $e) {
|
||||
// do nothing
|
||||
}
|
||||
}
|
||||
public function __sleep()
|
||||
{
|
||||
$this->close();
|
||||
$reflClass = new \ReflectionClass($this);
|
||||
$keys = [];
|
||||
foreach ($reflClass->getProperties() as $reflProp) {
|
||||
if (!$reflProp->isStatic()) {
|
||||
$keys[] = $reflProp->getName();
|
||||
}
|
||||
}
|
||||
return $keys;
|
||||
}
|
||||
}
|
||||
82
vendor/Gcp/monolog/monolog/src/Monolog/Handler/HandlerInterface.php
vendored
Normal file
82
vendor/Gcp/monolog/monolog/src/Monolog/Handler/HandlerInterface.php
vendored
Normal file
@@ -0,0 +1,82 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
/**
|
||||
* Interface that all Monolog Handlers must implement
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
*/
|
||||
interface HandlerInterface
|
||||
{
|
||||
/**
|
||||
* Checks whether the given record will be handled by this handler.
|
||||
*
|
||||
* This is mostly done for performance reasons, to avoid calling processors for nothing.
|
||||
*
|
||||
* Handlers should still check the record levels within handle(), returning false in isHandling()
|
||||
* is no guarantee that handle() will not be called, and isHandling() might not be called
|
||||
* for a given record.
|
||||
*
|
||||
* @param array $record Partial log record containing only a level key
|
||||
*
|
||||
* @return bool
|
||||
*
|
||||
* @phpstan-param array{level: Level} $record
|
||||
*/
|
||||
public function isHandling(array $record) : bool;
|
||||
/**
|
||||
* Handles a record.
|
||||
*
|
||||
* All records may be passed to this method, and the handler should discard
|
||||
* those that it does not want to handle.
|
||||
*
|
||||
* The return value of this function controls the bubbling process of the handler stack.
|
||||
* Unless the bubbling is interrupted (by returning true), the Logger class will keep on
|
||||
* calling further handlers in the stack with a given log record.
|
||||
*
|
||||
* @param array $record The record to handle
|
||||
* @return bool true means that this handler handled the record, and that bubbling is not permitted.
|
||||
* false means the record was either not processed or that this handler allows bubbling.
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
public function handle(array $record) : bool;
|
||||
/**
|
||||
* Handles a set of records at once.
|
||||
*
|
||||
* @param array $records The records to handle (an array of record arrays)
|
||||
*
|
||||
* @phpstan-param Record[] $records
|
||||
*/
|
||||
public function handleBatch(array $records) : void;
|
||||
/**
|
||||
* Closes the handler.
|
||||
*
|
||||
* Ends a log cycle and frees all resources used by the handler.
|
||||
*
|
||||
* Closing a Handler means flushing all buffers and freeing any open resources/handles.
|
||||
*
|
||||
* Implementations have to be idempotent (i.e. it should be possible to call close several times without breakage)
|
||||
* and ideally handlers should be able to reopen themselves on handle() after they have been closed.
|
||||
*
|
||||
* This is useful at the end of a request and will be called automatically when the object
|
||||
* is destroyed if you extend Monolog\Handler\Handler.
|
||||
*
|
||||
* If you are thinking of calling this method yourself, most likely you should be
|
||||
* calling ResettableInterface::reset instead. Have a look.
|
||||
*/
|
||||
public function close() : void;
|
||||
}
|
||||
119
vendor/Gcp/monolog/monolog/src/Monolog/Handler/HandlerWrapper.php
vendored
Normal file
119
vendor/Gcp/monolog/monolog/src/Monolog/Handler/HandlerWrapper.php
vendored
Normal file
@@ -0,0 +1,119 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\ResettableInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* This simple wrapper class can be used to extend handlers functionality.
|
||||
*
|
||||
* Example: A custom filtering that can be applied to any handler.
|
||||
*
|
||||
* Inherit from this class and override handle() like this:
|
||||
*
|
||||
* public function handle(array $record)
|
||||
* {
|
||||
* if ($record meets certain conditions) {
|
||||
* return false;
|
||||
* }
|
||||
* return $this->handler->handle($record);
|
||||
* }
|
||||
*
|
||||
* @author Alexey Karapetov <alexey@karapetov.com>
|
||||
*/
|
||||
class HandlerWrapper implements HandlerInterface, ProcessableHandlerInterface, FormattableHandlerInterface, ResettableInterface
|
||||
{
|
||||
/**
|
||||
* @var HandlerInterface
|
||||
*/
|
||||
protected $handler;
|
||||
public function __construct(HandlerInterface $handler)
|
||||
{
|
||||
$this->handler = $handler;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
return $this->handler->isHandling($record);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
return $this->handler->handle($record);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
$this->handler->handleBatch($records);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
$this->handler->close();
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function pushProcessor(callable $callback) : HandlerInterface
|
||||
{
|
||||
if ($this->handler instanceof ProcessableHandlerInterface) {
|
||||
$this->handler->pushProcessor($callback);
|
||||
return $this;
|
||||
}
|
||||
throw new \LogicException('The wrapped handler does not implement ' . ProcessableHandlerInterface::class);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function popProcessor() : callable
|
||||
{
|
||||
if ($this->handler instanceof ProcessableHandlerInterface) {
|
||||
return $this->handler->popProcessor();
|
||||
}
|
||||
throw new \LogicException('The wrapped handler does not implement ' . ProcessableHandlerInterface::class);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
if ($this->handler instanceof FormattableHandlerInterface) {
|
||||
$this->handler->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
throw new \LogicException('The wrapped handler does not implement ' . FormattableHandlerInterface::class);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
if ($this->handler instanceof FormattableHandlerInterface) {
|
||||
return $this->handler->getFormatter();
|
||||
}
|
||||
throw new \LogicException('The wrapped handler does not implement ' . FormattableHandlerInterface::class);
|
||||
}
|
||||
public function reset()
|
||||
{
|
||||
if ($this->handler instanceof ResettableInterface) {
|
||||
$this->handler->reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
61
vendor/Gcp/monolog/monolog/src/Monolog/Handler/IFTTTHandler.php
vendored
Normal file
61
vendor/Gcp/monolog/monolog/src/Monolog/Handler/IFTTTHandler.php
vendored
Normal file
@@ -0,0 +1,61 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* IFTTTHandler uses cURL to trigger IFTTT Maker actions
|
||||
*
|
||||
* Register a secret key and trigger/event name at https://ifttt.com/maker
|
||||
*
|
||||
* value1 will be the channel from monolog's Logger constructor,
|
||||
* value2 will be the level name (ERROR, WARNING, ..)
|
||||
* value3 will be the log record's message
|
||||
*
|
||||
* @author Nehal Patel <nehal@nehalpatel.me>
|
||||
*/
|
||||
class IFTTTHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var string */
|
||||
private $eventName;
|
||||
/** @var string */
|
||||
private $secretKey;
|
||||
/**
|
||||
* @param string $eventName The name of the IFTTT Maker event that should be triggered
|
||||
* @param string $secretKey A valid IFTTT secret key
|
||||
*/
|
||||
public function __construct(string $eventName, string $secretKey, $level = Logger::ERROR, bool $bubble = \true)
|
||||
{
|
||||
if (!\extension_loaded('curl')) {
|
||||
throw new MissingExtensionException('The curl extension is needed to use the IFTTTHandler');
|
||||
}
|
||||
$this->eventName = $eventName;
|
||||
$this->secretKey = $secretKey;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function write(array $record) : void
|
||||
{
|
||||
$postData = ["value1" => $record["channel"], "value2" => $record["level_name"], "value3" => $record["message"]];
|
||||
$postString = Utils::jsonEncode($postData);
|
||||
$ch = \curl_init();
|
||||
\curl_setopt($ch, \CURLOPT_URL, "https://maker.ifttt.com/trigger/" . $this->eventName . "/with/key/" . $this->secretKey);
|
||||
\curl_setopt($ch, \CURLOPT_POST, \true);
|
||||
\curl_setopt($ch, \CURLOPT_RETURNTRANSFER, \true);
|
||||
\curl_setopt($ch, \CURLOPT_POSTFIELDS, $postString);
|
||||
\curl_setopt($ch, \CURLOPT_HTTPHEADER, ["Content-Type: application/json"]);
|
||||
Curl\Util::execute($ch);
|
||||
}
|
||||
}
|
||||
50
vendor/Gcp/monolog/monolog/src/Monolog/Handler/InsightOpsHandler.php
vendored
Normal file
50
vendor/Gcp/monolog/monolog/src/Monolog/Handler/InsightOpsHandler.php
vendored
Normal file
@@ -0,0 +1,50 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Inspired on LogEntriesHandler.
|
||||
*
|
||||
* @author Robert Kaufmann III <rok3@rok3.me>
|
||||
* @author Gabriel Machado <gabriel.ms1@hotmail.com>
|
||||
*/
|
||||
class InsightOpsHandler extends SocketHandler
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $logToken;
|
||||
/**
|
||||
* @param string $token Log token supplied by InsightOps
|
||||
* @param string $region Region where InsightOps account is hosted. Could be 'us' or 'eu'.
|
||||
* @param bool $useSSL Whether or not SSL encryption should be used
|
||||
*
|
||||
* @throws MissingExtensionException If SSL encryption is set to true and OpenSSL is missing
|
||||
*/
|
||||
public function __construct(string $token, string $region = 'us', bool $useSSL = \true, $level = Logger::DEBUG, bool $bubble = \true, bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
if ($useSSL && !\extension_loaded('openssl')) {
|
||||
throw new MissingExtensionException('The OpenSSL PHP plugin is required to use SSL encrypted connection for InsightOpsHandler');
|
||||
}
|
||||
$endpoint = $useSSL ? 'ssl://' . $region . '.data.logs.insight.rapid7.com:443' : $region . '.data.logs.insight.rapid7.com:80';
|
||||
parent::__construct($endpoint, $level, $bubble, $persistent, $timeout, $writingTimeout, $connectionTimeout, $chunkSize);
|
||||
$this->logToken = $token;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
return $this->logToken . ' ' . $record['formatted'];
|
||||
}
|
||||
}
|
||||
47
vendor/Gcp/monolog/monolog/src/Monolog/Handler/LogEntriesHandler.php
vendored
Normal file
47
vendor/Gcp/monolog/monolog/src/Monolog/Handler/LogEntriesHandler.php
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* @author Robert Kaufmann III <rok3@rok3.me>
|
||||
*/
|
||||
class LogEntriesHandler extends SocketHandler
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $logToken;
|
||||
/**
|
||||
* @param string $token Log token supplied by LogEntries
|
||||
* @param bool $useSSL Whether or not SSL encryption should be used.
|
||||
* @param string $host Custom hostname to send the data to if needed
|
||||
*
|
||||
* @throws MissingExtensionException If SSL encryption is set to true and OpenSSL is missing
|
||||
*/
|
||||
public function __construct(string $token, bool $useSSL = \true, $level = Logger::DEBUG, bool $bubble = \true, string $host = 'data.logentries.com', bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
if ($useSSL && !\extension_loaded('openssl')) {
|
||||
throw new MissingExtensionException('The OpenSSL PHP plugin is required to use SSL encrypted connection for LogEntriesHandler');
|
||||
}
|
||||
$endpoint = $useSSL ? 'ssl://' . $host . ':443' : $host . ':80';
|
||||
parent::__construct($endpoint, $level, $bubble, $persistent, $timeout, $writingTimeout, $connectionTimeout, $chunkSize);
|
||||
$this->logToken = $token;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
return $this->logToken . ' ' . $record['formatted'];
|
||||
}
|
||||
}
|
||||
133
vendor/Gcp/monolog/monolog/src/Monolog/Handler/LogglyHandler.php
vendored
Normal file
133
vendor/Gcp/monolog/monolog/src/Monolog/Handler/LogglyHandler.php
vendored
Normal file
@@ -0,0 +1,133 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LogglyFormatter;
|
||||
use function array_key_exists;
|
||||
use CurlHandle;
|
||||
/**
|
||||
* Sends errors to Loggly.
|
||||
*
|
||||
* @author Przemek Sobstel <przemek@sobstel.org>
|
||||
* @author Adam Pancutt <adam@pancutt.com>
|
||||
* @author Gregory Barchard <gregory@barchard.net>
|
||||
*/
|
||||
class LogglyHandler extends AbstractProcessingHandler
|
||||
{
|
||||
protected const HOST = 'logs-01.loggly.com';
|
||||
protected const ENDPOINT_SINGLE = 'inputs';
|
||||
protected const ENDPOINT_BATCH = 'bulk';
|
||||
/**
|
||||
* Caches the curl handlers for every given endpoint.
|
||||
*
|
||||
* @var resource[]|CurlHandle[]
|
||||
*/
|
||||
protected $curlHandlers = [];
|
||||
/** @var string */
|
||||
protected $token;
|
||||
/** @var string[] */
|
||||
protected $tag = [];
|
||||
/**
|
||||
* @param string $token API token supplied by Loggly
|
||||
*
|
||||
* @throws MissingExtensionException If the curl extension is missing
|
||||
*/
|
||||
public function __construct(string $token, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
if (!\extension_loaded('curl')) {
|
||||
throw new MissingExtensionException('The curl extension is needed to use the LogglyHandler');
|
||||
}
|
||||
$this->token = $token;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* Loads and returns the shared curl handler for the given endpoint.
|
||||
*
|
||||
* @param string $endpoint
|
||||
*
|
||||
* @return resource|CurlHandle
|
||||
*/
|
||||
protected function getCurlHandler(string $endpoint)
|
||||
{
|
||||
if (!array_key_exists($endpoint, $this->curlHandlers)) {
|
||||
$this->curlHandlers[$endpoint] = $this->loadCurlHandle($endpoint);
|
||||
}
|
||||
return $this->curlHandlers[$endpoint];
|
||||
}
|
||||
/**
|
||||
* Starts a fresh curl session for the given endpoint and returns its handler.
|
||||
*
|
||||
* @param string $endpoint
|
||||
*
|
||||
* @return resource|CurlHandle
|
||||
*/
|
||||
private function loadCurlHandle(string $endpoint)
|
||||
{
|
||||
$url = \sprintf("https://%s/%s/%s/", static::HOST, $endpoint, $this->token);
|
||||
$ch = \curl_init();
|
||||
\curl_setopt($ch, \CURLOPT_URL, $url);
|
||||
\curl_setopt($ch, \CURLOPT_POST, \true);
|
||||
\curl_setopt($ch, \CURLOPT_RETURNTRANSFER, \true);
|
||||
return $ch;
|
||||
}
|
||||
/**
|
||||
* @param string[]|string $tag
|
||||
*/
|
||||
public function setTag($tag) : self
|
||||
{
|
||||
$tag = !empty($tag) ? $tag : [];
|
||||
$this->tag = \is_array($tag) ? $tag : [$tag];
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @param string[]|string $tag
|
||||
*/
|
||||
public function addTag($tag) : self
|
||||
{
|
||||
if (!empty($tag)) {
|
||||
$tag = \is_array($tag) ? $tag : [$tag];
|
||||
$this->tag = \array_unique(\array_merge($this->tag, $tag));
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->send($record["formatted"], static::ENDPOINT_SINGLE);
|
||||
}
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
$level = $this->level;
|
||||
$records = \array_filter($records, function ($record) use($level) {
|
||||
return $record['level'] >= $level;
|
||||
});
|
||||
if ($records) {
|
||||
$this->send($this->getFormatter()->formatBatch($records), static::ENDPOINT_BATCH);
|
||||
}
|
||||
}
|
||||
protected function send(string $data, string $endpoint) : void
|
||||
{
|
||||
$ch = $this->getCurlHandler($endpoint);
|
||||
$headers = ['Content-Type: application/json'];
|
||||
if (!empty($this->tag)) {
|
||||
$headers[] = 'X-LOGGLY-TAG: ' . \implode(',', $this->tag);
|
||||
}
|
||||
\curl_setopt($ch, \CURLOPT_POSTFIELDS, $data);
|
||||
\curl_setopt($ch, \CURLOPT_HTTPHEADER, $headers);
|
||||
Curl\Util::execute($ch, 5, \false);
|
||||
}
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LogglyFormatter();
|
||||
}
|
||||
}
|
||||
75
vendor/Gcp/monolog/monolog/src/Monolog/Handler/LogmaticHandler.php
vendored
Normal file
75
vendor/Gcp/monolog/monolog/src/Monolog/Handler/LogmaticHandler.php
vendored
Normal file
@@ -0,0 +1,75 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LogmaticFormatter;
|
||||
/**
|
||||
* @author Julien Breux <julien.breux@gmail.com>
|
||||
*/
|
||||
class LogmaticHandler extends SocketHandler
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $logToken;
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $hostname;
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $appname;
|
||||
/**
|
||||
* @param string $token Log token supplied by Logmatic.
|
||||
* @param string $hostname Host name supplied by Logmatic.
|
||||
* @param string $appname Application name supplied by Logmatic.
|
||||
* @param bool $useSSL Whether or not SSL encryption should be used.
|
||||
*
|
||||
* @throws MissingExtensionException If SSL encryption is set to true and OpenSSL is missing
|
||||
*/
|
||||
public function __construct(string $token, string $hostname = '', string $appname = '', bool $useSSL = \true, $level = Logger::DEBUG, bool $bubble = \true, bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
if ($useSSL && !\extension_loaded('openssl')) {
|
||||
throw new MissingExtensionException('The OpenSSL PHP extension is required to use SSL encrypted connection for LogmaticHandler');
|
||||
}
|
||||
$endpoint = $useSSL ? 'ssl://api.logmatic.io:10515' : 'api.logmatic.io:10514';
|
||||
$endpoint .= '/v1/';
|
||||
parent::__construct($endpoint, $level, $bubble, $persistent, $timeout, $writingTimeout, $connectionTimeout, $chunkSize);
|
||||
$this->logToken = $token;
|
||||
$this->hostname = $hostname;
|
||||
$this->appname = $appname;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
return $this->logToken . ' ' . $record['formatted'];
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
$formatter = new LogmaticFormatter();
|
||||
if (!empty($this->hostname)) {
|
||||
$formatter->setHostname($this->hostname);
|
||||
}
|
||||
if (!empty($this->appname)) {
|
||||
$formatter->setAppname($this->appname);
|
||||
}
|
||||
return $formatter;
|
||||
}
|
||||
}
|
||||
86
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MailHandler.php
vendored
Normal file
86
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MailHandler.php
vendored
Normal file
@@ -0,0 +1,86 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\HtmlFormatter;
|
||||
/**
|
||||
* Base class for all mail handlers
|
||||
*
|
||||
* @author Gyula Sallai
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
abstract class MailHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
$messages = [];
|
||||
foreach ($records as $record) {
|
||||
if ($record['level'] < $this->level) {
|
||||
continue;
|
||||
}
|
||||
/** @var Record $message */
|
||||
$message = $this->processRecord($record);
|
||||
$messages[] = $message;
|
||||
}
|
||||
if (!empty($messages)) {
|
||||
$this->send((string) $this->getFormatter()->formatBatch($messages), $messages);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Send a mail with the given content
|
||||
*
|
||||
* @param string $content formatted email body to be sent
|
||||
* @param array $records the array of log records that formed this content
|
||||
*
|
||||
* @phpstan-param Record[] $records
|
||||
*/
|
||||
protected abstract function send(string $content, array $records) : void;
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->send((string) $record['formatted'], [$record]);
|
||||
}
|
||||
/**
|
||||
* @phpstan-param non-empty-array<Record> $records
|
||||
* @phpstan-return Record
|
||||
*/
|
||||
protected function getHighestRecord(array $records) : array
|
||||
{
|
||||
$highestRecord = null;
|
||||
foreach ($records as $record) {
|
||||
if ($highestRecord === null || $highestRecord['level'] < $record['level']) {
|
||||
$highestRecord = $record;
|
||||
}
|
||||
}
|
||||
return $highestRecord;
|
||||
}
|
||||
protected function isHtmlBody(string $body) : bool
|
||||
{
|
||||
return ($body[0] ?? null) === '<';
|
||||
}
|
||||
/**
|
||||
* Gets the default formatter.
|
||||
*
|
||||
* @return FormatterInterface
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new HtmlFormatter();
|
||||
}
|
||||
}
|
||||
71
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MandrillHandler.php
vendored
Normal file
71
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MandrillHandler.php
vendored
Normal file
@@ -0,0 +1,71 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Swift;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Swift_Message;
|
||||
/**
|
||||
* MandrillHandler uses cURL to send the emails to the Mandrill API
|
||||
*
|
||||
* @author Adam Nicholson <adamnicholson10@gmail.com>
|
||||
*/
|
||||
class MandrillHandler extends MailHandler
|
||||
{
|
||||
/** @var Swift_Message */
|
||||
protected $message;
|
||||
/** @var string */
|
||||
protected $apiKey;
|
||||
/**
|
||||
* @psalm-param Swift_Message|callable(): Swift_Message $message
|
||||
*
|
||||
* @param string $apiKey A valid Mandrill API key
|
||||
* @param callable|Swift_Message $message An example message for real messages, only the body will be replaced
|
||||
*/
|
||||
public function __construct(string $apiKey, $message, $level = Logger::ERROR, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
if (!$message instanceof Swift_Message && \is_callable($message)) {
|
||||
$message = $message();
|
||||
}
|
||||
if (!$message instanceof Swift_Message) {
|
||||
throw new \InvalidArgumentException('You must provide either a Swift_Message instance or a callable returning it');
|
||||
}
|
||||
$this->message = $message;
|
||||
$this->apiKey = $apiKey;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function send(string $content, array $records) : void
|
||||
{
|
||||
$mime = 'text/plain';
|
||||
if ($this->isHtmlBody($content)) {
|
||||
$mime = 'text/html';
|
||||
}
|
||||
$message = clone $this->message;
|
||||
$message->setBody($content, $mime);
|
||||
/** @phpstan-ignore-next-line */
|
||||
if (\version_compare(Swift::VERSION, '6.0.0', '>=')) {
|
||||
$message->setDate(new \DateTimeImmutable());
|
||||
} else {
|
||||
/** @phpstan-ignore-next-line */
|
||||
$message->setDate(\time());
|
||||
}
|
||||
$ch = \curl_init();
|
||||
\curl_setopt($ch, \CURLOPT_URL, 'https://mandrillapp.com/api/1.0/messages/send-raw.json');
|
||||
\curl_setopt($ch, \CURLOPT_POST, 1);
|
||||
\curl_setopt($ch, \CURLOPT_RETURNTRANSFER, 1);
|
||||
\curl_setopt($ch, \CURLOPT_POSTFIELDS, \http_build_query(['key' => $this->apiKey, 'raw_message' => (string) $message, 'async' => \false]));
|
||||
Curl\Util::execute($ch);
|
||||
}
|
||||
}
|
||||
21
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MissingExtensionException.php
vendored
Normal file
21
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MissingExtensionException.php
vendored
Normal file
@@ -0,0 +1,21 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
/**
|
||||
* Exception can be thrown if an extension for a handler is missing
|
||||
*
|
||||
* @author Christian Bergau <cbergau86@gmail.com>
|
||||
*/
|
||||
class MissingExtensionException extends \Exception
|
||||
{
|
||||
}
|
||||
79
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MongoDBHandler.php
vendored
Normal file
79
vendor/Gcp/monolog/monolog/src/Monolog/Handler/MongoDBHandler.php
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use MongoDB\Driver\BulkWrite;
|
||||
use MongoDB\Driver\Manager;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\MongoDB\Client;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\MongoDBFormatter;
|
||||
/**
|
||||
* Logs to a MongoDB database.
|
||||
*
|
||||
* Usage example:
|
||||
*
|
||||
* $log = new \Monolog\Logger('application');
|
||||
* $client = new \MongoDB\Client('mongodb://localhost:27017');
|
||||
* $mongodb = new \Monolog\Handler\MongoDBHandler($client, 'logs', 'prod');
|
||||
* $log->pushHandler($mongodb);
|
||||
*
|
||||
* The above examples uses the MongoDB PHP library's client class; however, the
|
||||
* MongoDB\Driver\Manager class from ext-mongodb is also supported.
|
||||
*/
|
||||
class MongoDBHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var \MongoDB\Collection */
|
||||
private $collection;
|
||||
/** @var Client|Manager */
|
||||
private $manager;
|
||||
/** @var string */
|
||||
private $namespace;
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* @param Client|Manager $mongodb MongoDB library or driver client
|
||||
* @param string $database Database name
|
||||
* @param string $collection Collection name
|
||||
*/
|
||||
public function __construct($mongodb, string $database, string $collection, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
if (!($mongodb instanceof Client || $mongodb instanceof Manager)) {
|
||||
throw new \InvalidArgumentException('MongoDB\\Client or MongoDB\\Driver\\Manager instance required');
|
||||
}
|
||||
if ($mongodb instanceof Client) {
|
||||
$this->collection = $mongodb->selectCollection($database, $collection);
|
||||
} else {
|
||||
$this->manager = $mongodb;
|
||||
$this->namespace = $database . '.' . $collection;
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (isset($this->collection)) {
|
||||
$this->collection->insertOne($record['formatted']);
|
||||
}
|
||||
if (isset($this->manager, $this->namespace)) {
|
||||
$bulk = new BulkWrite();
|
||||
$bulk->insert($record["formatted"]);
|
||||
$this->manager->executeBulkWrite($this->namespace, $bulk);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new MongoDBFormatter();
|
||||
}
|
||||
}
|
||||
149
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NativeMailerHandler.php
vendored
Normal file
149
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NativeMailerHandler.php
vendored
Normal file
@@ -0,0 +1,149 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
/**
|
||||
* NativeMailerHandler uses the mail() function to send the emails
|
||||
*
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
* @author Mark Garrett <mark@moderndeveloperllc.com>
|
||||
*/
|
||||
class NativeMailerHandler extends MailHandler
|
||||
{
|
||||
/**
|
||||
* The email addresses to which the message will be sent
|
||||
* @var string[]
|
||||
*/
|
||||
protected $to;
|
||||
/**
|
||||
* The subject of the email
|
||||
* @var string
|
||||
*/
|
||||
protected $subject;
|
||||
/**
|
||||
* Optional headers for the message
|
||||
* @var string[]
|
||||
*/
|
||||
protected $headers = [];
|
||||
/**
|
||||
* Optional parameters for the message
|
||||
* @var string[]
|
||||
*/
|
||||
protected $parameters = [];
|
||||
/**
|
||||
* The wordwrap length for the message
|
||||
* @var int
|
||||
*/
|
||||
protected $maxColumnWidth;
|
||||
/**
|
||||
* The Content-type for the message
|
||||
* @var string|null
|
||||
*/
|
||||
protected $contentType;
|
||||
/**
|
||||
* The encoding for the message
|
||||
* @var string
|
||||
*/
|
||||
protected $encoding = 'utf-8';
|
||||
/**
|
||||
* @param string|string[] $to The receiver of the mail
|
||||
* @param string $subject The subject of the mail
|
||||
* @param string $from The sender of the mail
|
||||
* @param int $maxColumnWidth The maximum column width that the message lines will have
|
||||
*/
|
||||
public function __construct($to, string $subject, string $from, $level = Logger::ERROR, bool $bubble = \true, int $maxColumnWidth = 70)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->to = (array) $to;
|
||||
$this->subject = $subject;
|
||||
$this->addHeader(\sprintf('From: %s', $from));
|
||||
$this->maxColumnWidth = $maxColumnWidth;
|
||||
}
|
||||
/**
|
||||
* Add headers to the message
|
||||
*
|
||||
* @param string|string[] $headers Custom added headers
|
||||
*/
|
||||
public function addHeader($headers) : self
|
||||
{
|
||||
foreach ((array) $headers as $header) {
|
||||
if (\strpos($header, "\n") !== \false || \strpos($header, "\r") !== \false) {
|
||||
throw new \InvalidArgumentException('Headers can not contain newline characters for security reasons');
|
||||
}
|
||||
$this->headers[] = $header;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Add parameters to the message
|
||||
*
|
||||
* @param string|string[] $parameters Custom added parameters
|
||||
*/
|
||||
public function addParameter($parameters) : self
|
||||
{
|
||||
$this->parameters = \array_merge($this->parameters, (array) $parameters);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function send(string $content, array $records) : void
|
||||
{
|
||||
$contentType = $this->getContentType() ?: ($this->isHtmlBody($content) ? 'text/html' : 'text/plain');
|
||||
if ($contentType !== 'text/html') {
|
||||
$content = \wordwrap($content, $this->maxColumnWidth);
|
||||
}
|
||||
$headers = \ltrim(\implode("\r\n", $this->headers) . "\r\n", "\r\n");
|
||||
$headers .= 'Content-type: ' . $contentType . '; charset=' . $this->getEncoding() . "\r\n";
|
||||
if ($contentType === 'text/html' && \false === \strpos($headers, 'MIME-Version:')) {
|
||||
$headers .= 'MIME-Version: 1.0' . "\r\n";
|
||||
}
|
||||
$subject = $this->subject;
|
||||
if ($records) {
|
||||
$subjectFormatter = new LineFormatter($this->subject);
|
||||
$subject = $subjectFormatter->format($this->getHighestRecord($records));
|
||||
}
|
||||
$parameters = \implode(' ', $this->parameters);
|
||||
foreach ($this->to as $to) {
|
||||
\mail($to, $subject, $content, $headers, $parameters);
|
||||
}
|
||||
}
|
||||
public function getContentType() : ?string
|
||||
{
|
||||
return $this->contentType;
|
||||
}
|
||||
public function getEncoding() : string
|
||||
{
|
||||
return $this->encoding;
|
||||
}
|
||||
/**
|
||||
* @param string $contentType The content type of the email - Defaults to text/plain. Use text/html for HTML messages.
|
||||
*/
|
||||
public function setContentType(string $contentType) : self
|
||||
{
|
||||
if (\strpos($contentType, "\n") !== \false || \strpos($contentType, "\r") !== \false) {
|
||||
throw new \InvalidArgumentException('The content type can not contain newline characters to prevent email header injection');
|
||||
}
|
||||
$this->contentType = $contentType;
|
||||
return $this;
|
||||
}
|
||||
public function setEncoding(string $encoding) : self
|
||||
{
|
||||
if (\strpos($encoding, "\n") !== \false || \strpos($encoding, "\r") !== \false) {
|
||||
throw new \InvalidArgumentException('The encoding can not contain newline characters to prevent email header injection');
|
||||
}
|
||||
$this->encoding = $encoding;
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
174
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NewRelicHandler.php
vendored
Normal file
174
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NewRelicHandler.php
vendored
Normal file
@@ -0,0 +1,174 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\NormalizerFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Class to record a log on a NewRelic application.
|
||||
* Enabling New Relic High Security mode may prevent capture of useful information.
|
||||
*
|
||||
* This handler requires a NormalizerFormatter to function and expects an array in $record['formatted']
|
||||
*
|
||||
* @see https://docs.newrelic.com/docs/agents/php-agent
|
||||
* @see https://docs.newrelic.com/docs/accounts-partnerships/accounts/security/high-security
|
||||
*/
|
||||
class NewRelicHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* Name of the New Relic application that will receive logs from this handler.
|
||||
*
|
||||
* @var ?string
|
||||
*/
|
||||
protected $appName;
|
||||
/**
|
||||
* Name of the current transaction
|
||||
*
|
||||
* @var ?string
|
||||
*/
|
||||
protected $transactionName;
|
||||
/**
|
||||
* Some context and extra data is passed into the handler as arrays of values. Do we send them as is
|
||||
* (useful if we are using the API), or explode them for display on the NewRelic RPM website?
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
protected $explodeArrays;
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @param string|null $appName
|
||||
* @param bool $explodeArrays
|
||||
* @param string|null $transactionName
|
||||
*/
|
||||
public function __construct($level = Logger::ERROR, bool $bubble = \true, ?string $appName = null, bool $explodeArrays = \false, ?string $transactionName = null)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->appName = $appName;
|
||||
$this->explodeArrays = $explodeArrays;
|
||||
$this->transactionName = $transactionName;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!$this->isNewRelicEnabled()) {
|
||||
throw new MissingExtensionException('The newrelic PHP extension is required to use the NewRelicHandler');
|
||||
}
|
||||
if ($appName = $this->getAppName($record['context'])) {
|
||||
$this->setNewRelicAppName($appName);
|
||||
}
|
||||
if ($transactionName = $this->getTransactionName($record['context'])) {
|
||||
$this->setNewRelicTransactionName($transactionName);
|
||||
unset($record['formatted']['context']['transaction_name']);
|
||||
}
|
||||
if (isset($record['context']['exception']) && $record['context']['exception'] instanceof \Throwable) {
|
||||
\newrelic_notice_error($record['message'], $record['context']['exception']);
|
||||
unset($record['formatted']['context']['exception']);
|
||||
} else {
|
||||
\newrelic_notice_error($record['message']);
|
||||
}
|
||||
if (isset($record['formatted']['context']) && \is_array($record['formatted']['context'])) {
|
||||
foreach ($record['formatted']['context'] as $key => $parameter) {
|
||||
if (\is_array($parameter) && $this->explodeArrays) {
|
||||
foreach ($parameter as $paramKey => $paramValue) {
|
||||
$this->setNewRelicParameter('context_' . $key . '_' . $paramKey, $paramValue);
|
||||
}
|
||||
} else {
|
||||
$this->setNewRelicParameter('context_' . $key, $parameter);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isset($record['formatted']['extra']) && \is_array($record['formatted']['extra'])) {
|
||||
foreach ($record['formatted']['extra'] as $key => $parameter) {
|
||||
if (\is_array($parameter) && $this->explodeArrays) {
|
||||
foreach ($parameter as $paramKey => $paramValue) {
|
||||
$this->setNewRelicParameter('extra_' . $key . '_' . $paramKey, $paramValue);
|
||||
}
|
||||
} else {
|
||||
$this->setNewRelicParameter('extra_' . $key, $parameter);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Checks whether the NewRelic extension is enabled in the system.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
protected function isNewRelicEnabled() : bool
|
||||
{
|
||||
return \extension_loaded('newrelic');
|
||||
}
|
||||
/**
|
||||
* Returns the appname where this log should be sent. Each log can override the default appname, set in this
|
||||
* handler's constructor, by providing the appname in it's context.
|
||||
*
|
||||
* @param mixed[] $context
|
||||
*/
|
||||
protected function getAppName(array $context) : ?string
|
||||
{
|
||||
if (isset($context['appname'])) {
|
||||
return $context['appname'];
|
||||
}
|
||||
return $this->appName;
|
||||
}
|
||||
/**
|
||||
* Returns the name of the current transaction. Each log can override the default transaction name, set in this
|
||||
* handler's constructor, by providing the transaction_name in it's context
|
||||
*
|
||||
* @param mixed[] $context
|
||||
*/
|
||||
protected function getTransactionName(array $context) : ?string
|
||||
{
|
||||
if (isset($context['transaction_name'])) {
|
||||
return $context['transaction_name'];
|
||||
}
|
||||
return $this->transactionName;
|
||||
}
|
||||
/**
|
||||
* Sets the NewRelic application that should receive this log.
|
||||
*/
|
||||
protected function setNewRelicAppName(string $appName) : void
|
||||
{
|
||||
\newrelic_set_appname($appName);
|
||||
}
|
||||
/**
|
||||
* Overwrites the name of the current transaction
|
||||
*/
|
||||
protected function setNewRelicTransactionName(string $transactionName) : void
|
||||
{
|
||||
\newrelic_name_transaction($transactionName);
|
||||
}
|
||||
/**
|
||||
* @param string $key
|
||||
* @param mixed $value
|
||||
*/
|
||||
protected function setNewRelicParameter(string $key, $value) : void
|
||||
{
|
||||
if (null === $value || \is_scalar($value)) {
|
||||
\newrelic_add_custom_parameter($key, $value);
|
||||
} else {
|
||||
\newrelic_add_custom_parameter($key, Utils::jsonEncode($value, null, \true));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new NormalizerFormatter();
|
||||
}
|
||||
}
|
||||
39
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NoopHandler.php
vendored
Normal file
39
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NoopHandler.php
vendored
Normal file
@@ -0,0 +1,39 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
/**
|
||||
* No-op
|
||||
*
|
||||
* This handler handles anything, but does nothing, and does not stop bubbling to the rest of the stack.
|
||||
* This can be used for testing, or to disable a handler when overriding a configuration without
|
||||
* influencing the rest of the stack.
|
||||
*
|
||||
* @author Roel Harbers <roelharbers@gmail.com>
|
||||
*/
|
||||
class NoopHandler extends Handler
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
return \true;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
return \false;
|
||||
}
|
||||
}
|
||||
56
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NullHandler.php
vendored
Normal file
56
vendor/Gcp/monolog/monolog/src/Monolog/Handler/NullHandler.php
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Blackhole
|
||||
*
|
||||
* Any record it can handle will be thrown away. This can be used
|
||||
* to put on top of an existing stack to override it temporarily.
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
class NullHandler extends Handler
|
||||
{
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
private $level;
|
||||
/**
|
||||
* @param string|int $level The minimum logging level at which this handler will be triggered
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function __construct($level = Logger::DEBUG)
|
||||
{
|
||||
$this->level = Logger::toMonologLevel($level);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
return $record['level'] >= $this->level;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
return $record['level'] >= $this->level;
|
||||
}
|
||||
}
|
||||
119
vendor/Gcp/monolog/monolog/src/Monolog/Handler/OverflowHandler.php
vendored
Normal file
119
vendor/Gcp/monolog/monolog/src/Monolog/Handler/OverflowHandler.php
vendored
Normal file
@@ -0,0 +1,119 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Handler to only pass log messages when a certain threshold of number of messages is reached.
|
||||
*
|
||||
* This can be useful in cases of processing a batch of data, but you're for example only interested
|
||||
* in case it fails catastrophically instead of a warning for 1 or 2 events. Worse things can happen, right?
|
||||
*
|
||||
* Usage example:
|
||||
*
|
||||
* ```
|
||||
* $log = new Logger('application');
|
||||
* $handler = new SomeHandler(...)
|
||||
*
|
||||
* // Pass all warnings to the handler when more than 10 & all error messages when more then 5
|
||||
* $overflow = new OverflowHandler($handler, [Logger::WARNING => 10, Logger::ERROR => 5]);
|
||||
*
|
||||
* $log->pushHandler($overflow);
|
||||
*```
|
||||
*
|
||||
* @author Kris Buist <krisbuist@gmail.com>
|
||||
*/
|
||||
class OverflowHandler extends AbstractHandler implements FormattableHandlerInterface
|
||||
{
|
||||
/** @var HandlerInterface */
|
||||
private $handler;
|
||||
/** @var int[] */
|
||||
private $thresholdMap = [Logger::DEBUG => 0, Logger::INFO => 0, Logger::NOTICE => 0, Logger::WARNING => 0, Logger::ERROR => 0, Logger::CRITICAL => 0, Logger::ALERT => 0, Logger::EMERGENCY => 0];
|
||||
/**
|
||||
* Buffer of all messages passed to the handler before the threshold was reached
|
||||
*
|
||||
* @var mixed[][]
|
||||
*/
|
||||
private $buffer = [];
|
||||
/**
|
||||
* @param HandlerInterface $handler
|
||||
* @param int[] $thresholdMap Dictionary of logger level => threshold
|
||||
*/
|
||||
public function __construct(HandlerInterface $handler, array $thresholdMap = [], $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
$this->handler = $handler;
|
||||
foreach ($thresholdMap as $thresholdLevel => $threshold) {
|
||||
$this->thresholdMap[$thresholdLevel] = $threshold;
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* Handles a record.
|
||||
*
|
||||
* All records may be passed to this method, and the handler should discard
|
||||
* those that it does not want to handle.
|
||||
*
|
||||
* The return value of this function controls the bubbling process of the handler stack.
|
||||
* Unless the bubbling is interrupted (by returning true), the Logger class will keep on
|
||||
* calling further handlers in the stack with a given log record.
|
||||
*
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($record['level'] < $this->level) {
|
||||
return \false;
|
||||
}
|
||||
$level = $record['level'];
|
||||
if (!isset($this->thresholdMap[$level])) {
|
||||
$this->thresholdMap[$level] = 0;
|
||||
}
|
||||
if ($this->thresholdMap[$level] > 0) {
|
||||
// The overflow threshold is not yet reached, so we're buffering the record and lowering the threshold by 1
|
||||
$this->thresholdMap[$level]--;
|
||||
$this->buffer[$level][] = $record;
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
if ($this->thresholdMap[$level] == 0) {
|
||||
// This current message is breaking the threshold. Flush the buffer and continue handling the current record
|
||||
foreach ($this->buffer[$level] ?? [] as $buffered) {
|
||||
$this->handler->handle($buffered);
|
||||
}
|
||||
$this->thresholdMap[$level]--;
|
||||
unset($this->buffer[$level]);
|
||||
}
|
||||
$this->handler->handle($record);
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
if ($this->handler instanceof FormattableHandlerInterface) {
|
||||
$this->handler->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($this->handler) . ' does not support formatters.');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
if ($this->handler instanceof FormattableHandlerInterface) {
|
||||
return $this->handler->getFormatter();
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($this->handler) . ' does not support formatters.');
|
||||
}
|
||||
}
|
||||
255
vendor/Gcp/monolog/monolog/src/Monolog/Handler/PHPConsoleHandler.php
vendored
Normal file
255
vendor/Gcp/monolog/monolog/src/Monolog/Handler/PHPConsoleHandler.php
vendored
Normal file
@@ -0,0 +1,255 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\PhpConsole\Connector;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\PhpConsole\Handler as VendorPhpConsoleHandler;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\PhpConsole\Helper;
|
||||
/**
|
||||
* Monolog handler for Google Chrome extension "PHP Console"
|
||||
*
|
||||
* Display PHP error/debug log messages in Google Chrome console and notification popups, executes PHP code remotely
|
||||
*
|
||||
* Usage:
|
||||
* 1. Install Google Chrome extension [now dead and removed from the chrome store]
|
||||
* 2. See overview https://github.com/barbushin/php-console#overview
|
||||
* 3. Install PHP Console library https://github.com/barbushin/php-console#installation
|
||||
* 4. Example (result will looks like http://i.hizliresim.com/vg3Pz4.png)
|
||||
*
|
||||
* $logger = new \Monolog\Logger('all', array(new \Monolog\Handler\PHPConsoleHandler()));
|
||||
* \Monolog\ErrorHandler::register($logger);
|
||||
* echo $undefinedVar;
|
||||
* $logger->debug('SELECT * FROM users', array('db', 'time' => 0.012));
|
||||
* PC::debug($_SERVER); // PHP Console debugger for any type of vars
|
||||
*
|
||||
* @author Sergey Barbushin https://www.linkedin.com/in/barbushin
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @deprecated Since 2.8.0 and 3.2.0, PHPConsole is abandoned and thus we will drop this handler in Monolog 4
|
||||
*/
|
||||
class PHPConsoleHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var array<string, mixed> */
|
||||
private $options = [
|
||||
'enabled' => \true,
|
||||
// bool Is PHP Console server enabled
|
||||
'classesPartialsTraceIgnore' => ['DeliciousBrains\\WP_Offload_Media\\Gcp\\Monolog\\'],
|
||||
// array Hide calls of classes started with...
|
||||
'debugTagsKeysInContext' => [0, 'tag'],
|
||||
// bool Is PHP Console server enabled
|
||||
'useOwnErrorsHandler' => \false,
|
||||
// bool Enable errors handling
|
||||
'useOwnExceptionsHandler' => \false,
|
||||
// bool Enable exceptions handling
|
||||
'sourcesBasePath' => null,
|
||||
// string Base path of all project sources to strip in errors source paths
|
||||
'registerHelper' => \true,
|
||||
// bool Register PhpConsole\Helper that allows short debug calls like PC::debug($var, 'ta.g.s')
|
||||
'serverEncoding' => null,
|
||||
// string|null Server internal encoding
|
||||
'headersLimit' => null,
|
||||
// int|null Set headers size limit for your web-server
|
||||
'password' => null,
|
||||
// string|null Protect PHP Console connection by password
|
||||
'enableSslOnlyMode' => \false,
|
||||
// bool Force connection by SSL for clients with PHP Console installed
|
||||
'ipMasks' => [],
|
||||
// array Set IP masks of clients that will be allowed to connect to PHP Console: array('192.168.*.*', '127.0.0.1')
|
||||
'enableEvalListener' => \false,
|
||||
// bool Enable eval request to be handled by eval dispatcher(if enabled, 'password' option is also required)
|
||||
'dumperDetectCallbacks' => \false,
|
||||
// bool Convert callback items in dumper vars to (callback SomeClass::someMethod) strings
|
||||
'dumperLevelLimit' => 5,
|
||||
// int Maximum dumped vars array or object nested dump level
|
||||
'dumperItemsCountLimit' => 100,
|
||||
// int Maximum dumped var same level array items or object properties number
|
||||
'dumperItemSizeLimit' => 5000,
|
||||
// int Maximum length of any string or dumped array item
|
||||
'dumperDumpSizeLimit' => 500000,
|
||||
// int Maximum approximate size of dumped vars result formatted in JSON
|
||||
'detectDumpTraceAndSource' => \false,
|
||||
// bool Autodetect and append trace data to debug
|
||||
'dataStorage' => null,
|
||||
];
|
||||
/** @var Connector */
|
||||
private $connector;
|
||||
/**
|
||||
* @param array<string, mixed> $options See \Monolog\Handler\PHPConsoleHandler::$options for more details
|
||||
* @param Connector|null $connector Instance of \PhpConsole\Connector class (optional)
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
public function __construct(array $options = [], ?Connector $connector = null, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
if (!\class_exists('DeliciousBrains\\WP_Offload_Media\\Gcp\\PhpConsole\\Connector')) {
|
||||
throw new \RuntimeException('PHP Console library not found. See https://github.com/barbushin/php-console#installation');
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
$this->options = $this->initOptions($options);
|
||||
$this->connector = $this->initConnector($connector);
|
||||
}
|
||||
/**
|
||||
* @param array<string, mixed> $options
|
||||
*
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
private function initOptions(array $options) : array
|
||||
{
|
||||
$wrongOptions = \array_diff(\array_keys($options), \array_keys($this->options));
|
||||
if ($wrongOptions) {
|
||||
throw new \RuntimeException('Unknown options: ' . \implode(', ', $wrongOptions));
|
||||
}
|
||||
return \array_replace($this->options, $options);
|
||||
}
|
||||
private function initConnector(?Connector $connector = null) : Connector
|
||||
{
|
||||
if (!$connector) {
|
||||
if ($this->options['dataStorage']) {
|
||||
Connector::setPostponeStorage($this->options['dataStorage']);
|
||||
}
|
||||
$connector = Connector::getInstance();
|
||||
}
|
||||
if ($this->options['registerHelper'] && !Helper::isRegistered()) {
|
||||
Helper::register();
|
||||
}
|
||||
if ($this->options['enabled'] && $connector->isActiveClient()) {
|
||||
if ($this->options['useOwnErrorsHandler'] || $this->options['useOwnExceptionsHandler']) {
|
||||
$handler = VendorPhpConsoleHandler::getInstance();
|
||||
$handler->setHandleErrors($this->options['useOwnErrorsHandler']);
|
||||
$handler->setHandleExceptions($this->options['useOwnExceptionsHandler']);
|
||||
$handler->start();
|
||||
}
|
||||
if ($this->options['sourcesBasePath']) {
|
||||
$connector->setSourcesBasePath($this->options['sourcesBasePath']);
|
||||
}
|
||||
if ($this->options['serverEncoding']) {
|
||||
$connector->setServerEncoding($this->options['serverEncoding']);
|
||||
}
|
||||
if ($this->options['password']) {
|
||||
$connector->setPassword($this->options['password']);
|
||||
}
|
||||
if ($this->options['enableSslOnlyMode']) {
|
||||
$connector->enableSslOnlyMode();
|
||||
}
|
||||
if ($this->options['ipMasks']) {
|
||||
$connector->setAllowedIpMasks($this->options['ipMasks']);
|
||||
}
|
||||
if ($this->options['headersLimit']) {
|
||||
$connector->setHeadersLimit($this->options['headersLimit']);
|
||||
}
|
||||
if ($this->options['detectDumpTraceAndSource']) {
|
||||
$connector->getDebugDispatcher()->detectTraceAndSource = \true;
|
||||
}
|
||||
$dumper = $connector->getDumper();
|
||||
$dumper->levelLimit = $this->options['dumperLevelLimit'];
|
||||
$dumper->itemsCountLimit = $this->options['dumperItemsCountLimit'];
|
||||
$dumper->itemSizeLimit = $this->options['dumperItemSizeLimit'];
|
||||
$dumper->dumpSizeLimit = $this->options['dumperDumpSizeLimit'];
|
||||
$dumper->detectCallbacks = $this->options['dumperDetectCallbacks'];
|
||||
if ($this->options['enableEvalListener']) {
|
||||
$connector->startEvalRequestsListener();
|
||||
}
|
||||
}
|
||||
return $connector;
|
||||
}
|
||||
public function getConnector() : Connector
|
||||
{
|
||||
return $this->connector;
|
||||
}
|
||||
/**
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
public function getOptions() : array
|
||||
{
|
||||
return $this->options;
|
||||
}
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($this->options['enabled'] && $this->connector->isActiveClient()) {
|
||||
return parent::handle($record);
|
||||
}
|
||||
return !$this->bubble;
|
||||
}
|
||||
/**
|
||||
* Writes the record down to the log of the implementing handler
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if ($record['level'] < Logger::NOTICE) {
|
||||
$this->handleDebugRecord($record);
|
||||
} elseif (isset($record['context']['exception']) && $record['context']['exception'] instanceof \Throwable) {
|
||||
$this->handleExceptionRecord($record);
|
||||
} else {
|
||||
$this->handleErrorRecord($record);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
private function handleDebugRecord(array $record) : void
|
||||
{
|
||||
$tags = $this->getRecordTags($record);
|
||||
$message = $record['message'];
|
||||
if ($record['context']) {
|
||||
$message .= ' ' . Utils::jsonEncode($this->connector->getDumper()->dump(\array_filter($record['context'])), null, \true);
|
||||
}
|
||||
$this->connector->getDebugDispatcher()->dispatchDebug($message, $tags, $this->options['classesPartialsTraceIgnore']);
|
||||
}
|
||||
/**
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
private function handleExceptionRecord(array $record) : void
|
||||
{
|
||||
$this->connector->getErrorsDispatcher()->dispatchException($record['context']['exception']);
|
||||
}
|
||||
/**
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
private function handleErrorRecord(array $record) : void
|
||||
{
|
||||
$context = $record['context'];
|
||||
$this->connector->getErrorsDispatcher()->dispatchError($context['code'] ?? null, $context['message'] ?? $record['message'], $context['file'] ?? null, $context['line'] ?? null, $this->options['classesPartialsTraceIgnore']);
|
||||
}
|
||||
/**
|
||||
* @phpstan-param Record $record
|
||||
* @return string
|
||||
*/
|
||||
private function getRecordTags(array &$record)
|
||||
{
|
||||
$tags = null;
|
||||
if (!empty($record['context'])) {
|
||||
$context =& $record['context'];
|
||||
foreach ($this->options['debugTagsKeysInContext'] as $key) {
|
||||
if (!empty($context[$key])) {
|
||||
$tags = $context[$key];
|
||||
if ($key === 0) {
|
||||
\array_shift($context);
|
||||
} else {
|
||||
unset($context[$key]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return $tags ?: \strtolower($record['level_name']);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter('%message%');
|
||||
}
|
||||
}
|
||||
168
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ProcessHandler.php
vendored
Normal file
168
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ProcessHandler.php
vendored
Normal file
@@ -0,0 +1,168 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Stores to STDIN of any process, specified by a command.
|
||||
*
|
||||
* Usage example:
|
||||
* <pre>
|
||||
* $log = new Logger('myLogger');
|
||||
* $log->pushHandler(new ProcessHandler('/usr/bin/php /var/www/monolog/someScript.php'));
|
||||
* </pre>
|
||||
*
|
||||
* @author Kolja Zuelsdorf <koljaz@web.de>
|
||||
*/
|
||||
class ProcessHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* Holds the process to receive data on its STDIN.
|
||||
*
|
||||
* @var resource|bool|null
|
||||
*/
|
||||
private $process;
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $command;
|
||||
/**
|
||||
* @var string|null
|
||||
*/
|
||||
private $cwd;
|
||||
/**
|
||||
* @var resource[]
|
||||
*/
|
||||
private $pipes = [];
|
||||
/**
|
||||
* @var array<int, string[]>
|
||||
*/
|
||||
protected const DESCRIPTOR_SPEC = [
|
||||
0 => ['pipe', 'r'],
|
||||
// STDIN is a pipe that the child will read from
|
||||
1 => ['pipe', 'w'],
|
||||
// STDOUT is a pipe that the child will write to
|
||||
2 => ['pipe', 'w'],
|
||||
];
|
||||
/**
|
||||
* @param string $command Command for the process to start. Absolute paths are recommended,
|
||||
* especially if you do not use the $cwd parameter.
|
||||
* @param string|null $cwd "Current working directory" (CWD) for the process to be executed in.
|
||||
* @throws \InvalidArgumentException
|
||||
*/
|
||||
public function __construct(string $command, $level = Logger::DEBUG, bool $bubble = \true, ?string $cwd = null)
|
||||
{
|
||||
if ($command === '') {
|
||||
throw new \InvalidArgumentException('The command argument must be a non-empty string.');
|
||||
}
|
||||
if ($cwd === '') {
|
||||
throw new \InvalidArgumentException('The optional CWD argument must be a non-empty string or null.');
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
$this->command = $command;
|
||||
$this->cwd = $cwd;
|
||||
}
|
||||
/**
|
||||
* Writes the record down to the log of the implementing handler
|
||||
*
|
||||
* @throws \UnexpectedValueException
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->ensureProcessIsStarted();
|
||||
$this->writeProcessInput($record['formatted']);
|
||||
$errors = $this->readProcessErrors();
|
||||
if (empty($errors) === \false) {
|
||||
throw new \UnexpectedValueException(\sprintf('Errors while writing to process: %s', $errors));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Makes sure that the process is actually started, and if not, starts it,
|
||||
* assigns the stream pipes, and handles startup errors, if any.
|
||||
*/
|
||||
private function ensureProcessIsStarted() : void
|
||||
{
|
||||
if (\is_resource($this->process) === \false) {
|
||||
$this->startProcess();
|
||||
$this->handleStartupErrors();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Starts the actual process and sets all streams to non-blocking.
|
||||
*/
|
||||
private function startProcess() : void
|
||||
{
|
||||
$this->process = \proc_open($this->command, static::DESCRIPTOR_SPEC, $this->pipes, $this->cwd);
|
||||
foreach ($this->pipes as $pipe) {
|
||||
\stream_set_blocking($pipe, \false);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Selects the STDERR stream, handles upcoming startup errors, and throws an exception, if any.
|
||||
*
|
||||
* @throws \UnexpectedValueException
|
||||
*/
|
||||
private function handleStartupErrors() : void
|
||||
{
|
||||
$selected = $this->selectErrorStream();
|
||||
if (\false === $selected) {
|
||||
throw new \UnexpectedValueException('Something went wrong while selecting a stream.');
|
||||
}
|
||||
$errors = $this->readProcessErrors();
|
||||
if (\is_resource($this->process) === \false || empty($errors) === \false) {
|
||||
throw new \UnexpectedValueException(\sprintf('The process "%s" could not be opened: ' . $errors, $this->command));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Selects the STDERR stream.
|
||||
*
|
||||
* @return int|bool
|
||||
*/
|
||||
protected function selectErrorStream()
|
||||
{
|
||||
$empty = [];
|
||||
$errorPipes = [$this->pipes[2]];
|
||||
return \stream_select($errorPipes, $empty, $empty, 1);
|
||||
}
|
||||
/**
|
||||
* Reads the errors of the process, if there are any.
|
||||
*
|
||||
* @codeCoverageIgnore
|
||||
* @return string Empty string if there are no errors.
|
||||
*/
|
||||
protected function readProcessErrors() : string
|
||||
{
|
||||
return (string) \stream_get_contents($this->pipes[2]);
|
||||
}
|
||||
/**
|
||||
* Writes to the input stream of the opened process.
|
||||
*
|
||||
* @codeCoverageIgnore
|
||||
*/
|
||||
protected function writeProcessInput(string $string) : void
|
||||
{
|
||||
\fwrite($this->pipes[0], $string);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
if (\is_resource($this->process)) {
|
||||
foreach ($this->pipes as $pipe) {
|
||||
\fclose($pipe);
|
||||
}
|
||||
\proc_close($this->process);
|
||||
$this->process = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
42
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ProcessableHandlerInterface.php
vendored
Normal file
42
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ProcessableHandlerInterface.php
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Processor\ProcessorInterface;
|
||||
/**
|
||||
* Interface to describe loggers that have processors
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
interface ProcessableHandlerInterface
|
||||
{
|
||||
/**
|
||||
* Adds a processor in the stack.
|
||||
*
|
||||
* @psalm-param ProcessorInterface|callable(Record): Record $callback
|
||||
*
|
||||
* @param ProcessorInterface|callable $callback
|
||||
* @return HandlerInterface self
|
||||
*/
|
||||
public function pushProcessor(callable $callback) : HandlerInterface;
|
||||
/**
|
||||
* Removes the processor on top of the stack and returns it.
|
||||
*
|
||||
* @psalm-return ProcessorInterface|callable(Record): Record $callback
|
||||
*
|
||||
* @throws \LogicException In case the processor stack is empty
|
||||
* @return callable|ProcessorInterface
|
||||
*/
|
||||
public function popProcessor() : callable;
|
||||
}
|
||||
69
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ProcessableHandlerTrait.php
vendored
Normal file
69
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ProcessableHandlerTrait.php
vendored
Normal file
@@ -0,0 +1,69 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\ResettableInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Processor\ProcessorInterface;
|
||||
/**
|
||||
* Helper trait for implementing ProcessableInterface
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
trait ProcessableHandlerTrait
|
||||
{
|
||||
/**
|
||||
* @var callable[]
|
||||
* @phpstan-var array<ProcessorInterface|callable(Record): Record>
|
||||
*/
|
||||
protected $processors = [];
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function pushProcessor(callable $callback) : HandlerInterface
|
||||
{
|
||||
\array_unshift($this->processors, $callback);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function popProcessor() : callable
|
||||
{
|
||||
if (!$this->processors) {
|
||||
throw new \LogicException('You tried to pop from an empty processor stack.');
|
||||
}
|
||||
return \array_shift($this->processors);
|
||||
}
|
||||
/**
|
||||
* Processes a record.
|
||||
*
|
||||
* @phpstan-param Record $record
|
||||
* @phpstan-return Record
|
||||
*/
|
||||
protected function processRecord(array $record) : array
|
||||
{
|
||||
foreach ($this->processors as $processor) {
|
||||
$record = $processor($record);
|
||||
}
|
||||
return $record;
|
||||
}
|
||||
protected function resetProcessors() : void
|
||||
{
|
||||
foreach ($this->processors as $processor) {
|
||||
if ($processor instanceof ResettableInterface) {
|
||||
$processor->reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
84
vendor/Gcp/monolog/monolog/src/Monolog/Handler/PsrHandler.php
vendored
Normal file
84
vendor/Gcp/monolog/monolog/src/Monolog/Handler/PsrHandler.php
vendored
Normal file
@@ -0,0 +1,84 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LoggerInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Proxies log messages to an existing PSR-3 compliant logger.
|
||||
*
|
||||
* If a formatter is configured, the formatter's output MUST be a string and the
|
||||
* formatted message will be fed to the wrapped PSR logger instead of the original
|
||||
* log record's message.
|
||||
*
|
||||
* @author Michael Moussa <michael.moussa@gmail.com>
|
||||
*/
|
||||
class PsrHandler extends AbstractHandler implements FormattableHandlerInterface
|
||||
{
|
||||
/**
|
||||
* PSR-3 compliant logger
|
||||
*
|
||||
* @var LoggerInterface
|
||||
*/
|
||||
protected $logger;
|
||||
/**
|
||||
* @var FormatterInterface|null
|
||||
*/
|
||||
protected $formatter;
|
||||
/**
|
||||
* @param LoggerInterface $logger The underlying PSR-3 compliant logger to which messages will be proxied
|
||||
*/
|
||||
public function __construct(LoggerInterface $logger, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->logger = $logger;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if (!$this->isHandling($record)) {
|
||||
return \false;
|
||||
}
|
||||
if ($this->formatter) {
|
||||
$formatted = $this->formatter->format($record);
|
||||
$this->logger->log(\strtolower($record['level_name']), (string) $formatted, $record['context']);
|
||||
} else {
|
||||
$this->logger->log(\strtolower($record['level_name']), $record['message'], $record['context']);
|
||||
}
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* Sets the formatter.
|
||||
*
|
||||
* @param FormatterInterface $formatter
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
$this->formatter = $formatter;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Gets the formatter.
|
||||
*
|
||||
* @return FormatterInterface
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
if (!$this->formatter) {
|
||||
throw new \LogicException('No formatter has been set and this handler does not have a default formatter');
|
||||
}
|
||||
return $this->formatter;
|
||||
}
|
||||
}
|
||||
170
vendor/Gcp/monolog/monolog/src/Monolog/Handler/PushoverHandler.php
vendored
Normal file
170
vendor/Gcp/monolog/monolog/src/Monolog/Handler/PushoverHandler.php
vendored
Normal file
@@ -0,0 +1,170 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Sends notifications through the pushover api to mobile phones
|
||||
*
|
||||
* @author Sebastian Göttschkes <sebastian.goettschkes@googlemail.com>
|
||||
* @see https://www.pushover.net/api
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
class PushoverHandler extends SocketHandler
|
||||
{
|
||||
/** @var string */
|
||||
private $token;
|
||||
/** @var array<int|string> */
|
||||
private $users;
|
||||
/** @var string */
|
||||
private $title;
|
||||
/** @var string|int|null */
|
||||
private $user = null;
|
||||
/** @var int */
|
||||
private $retry;
|
||||
/** @var int */
|
||||
private $expire;
|
||||
/** @var int */
|
||||
private $highPriorityLevel;
|
||||
/** @var int */
|
||||
private $emergencyLevel;
|
||||
/** @var bool */
|
||||
private $useFormattedMessage = \false;
|
||||
/**
|
||||
* All parameters that can be sent to Pushover
|
||||
* @see https://pushover.net/api
|
||||
* @var array<string, bool>
|
||||
*/
|
||||
private $parameterNames = ['token' => \true, 'user' => \true, 'message' => \true, 'device' => \true, 'title' => \true, 'url' => \true, 'url_title' => \true, 'priority' => \true, 'timestamp' => \true, 'sound' => \true, 'retry' => \true, 'expire' => \true, 'callback' => \true];
|
||||
/**
|
||||
* Sounds the api supports by default
|
||||
* @see https://pushover.net/api#sounds
|
||||
* @var string[]
|
||||
*/
|
||||
private $sounds = ['pushover', 'bike', 'bugle', 'cashregister', 'classical', 'cosmic', 'falling', 'gamelan', 'incoming', 'intermission', 'magic', 'mechanical', 'pianobar', 'siren', 'spacealarm', 'tugboat', 'alien', 'climb', 'persistent', 'echo', 'updown', 'none'];
|
||||
/**
|
||||
* @param string $token Pushover api token
|
||||
* @param string|array $users Pushover user id or array of ids the message will be sent to
|
||||
* @param string|null $title Title sent to the Pushover API
|
||||
* @param bool $useSSL Whether to connect via SSL. Required when pushing messages to users that are not
|
||||
* the pushover.net app owner. OpenSSL is required for this option.
|
||||
* @param string|int $highPriorityLevel The minimum logging level at which this handler will start
|
||||
* sending "high priority" requests to the Pushover API
|
||||
* @param string|int $emergencyLevel The minimum logging level at which this handler will start
|
||||
* sending "emergency" requests to the Pushover API
|
||||
* @param int $retry The retry parameter specifies how often (in seconds) the Pushover servers will
|
||||
* send the same notification to the user.
|
||||
* @param int $expire The expire parameter specifies how many seconds your notification will continue
|
||||
* to be retried for (every retry seconds).
|
||||
*
|
||||
* @phpstan-param string|array<int|string> $users
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $highPriorityLevel
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $emergencyLevel
|
||||
*/
|
||||
public function __construct(string $token, $users, ?string $title = null, $level = Logger::CRITICAL, bool $bubble = \true, bool $useSSL = \true, $highPriorityLevel = Logger::CRITICAL, $emergencyLevel = Logger::EMERGENCY, int $retry = 30, int $expire = 25200, bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
$connectionString = $useSSL ? 'ssl://api.pushover.net:443' : 'api.pushover.net:80';
|
||||
parent::__construct($connectionString, $level, $bubble, $persistent, $timeout, $writingTimeout, $connectionTimeout, $chunkSize);
|
||||
$this->token = $token;
|
||||
$this->users = (array) $users;
|
||||
$this->title = $title ?: (string) \gethostname();
|
||||
$this->highPriorityLevel = Logger::toMonologLevel($highPriorityLevel);
|
||||
$this->emergencyLevel = Logger::toMonologLevel($emergencyLevel);
|
||||
$this->retry = $retry;
|
||||
$this->expire = $expire;
|
||||
}
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
$content = $this->buildContent($record);
|
||||
return $this->buildHeader($content) . $content;
|
||||
}
|
||||
/**
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
private function buildContent(array $record) : string
|
||||
{
|
||||
// Pushover has a limit of 512 characters on title and message combined.
|
||||
$maxMessageLength = 512 - \strlen($this->title);
|
||||
$message = $this->useFormattedMessage ? $record['formatted'] : $record['message'];
|
||||
$message = Utils::substr($message, 0, $maxMessageLength);
|
||||
$timestamp = $record['datetime']->getTimestamp();
|
||||
$dataArray = ['token' => $this->token, 'user' => $this->user, 'message' => $message, 'title' => $this->title, 'timestamp' => $timestamp];
|
||||
if (isset($record['level']) && $record['level'] >= $this->emergencyLevel) {
|
||||
$dataArray['priority'] = 2;
|
||||
$dataArray['retry'] = $this->retry;
|
||||
$dataArray['expire'] = $this->expire;
|
||||
} elseif (isset($record['level']) && $record['level'] >= $this->highPriorityLevel) {
|
||||
$dataArray['priority'] = 1;
|
||||
}
|
||||
// First determine the available parameters
|
||||
$context = \array_intersect_key($record['context'], $this->parameterNames);
|
||||
$extra = \array_intersect_key($record['extra'], $this->parameterNames);
|
||||
// Least important info should be merged with subsequent info
|
||||
$dataArray = \array_merge($extra, $context, $dataArray);
|
||||
// Only pass sounds that are supported by the API
|
||||
if (isset($dataArray['sound']) && !\in_array($dataArray['sound'], $this->sounds)) {
|
||||
unset($dataArray['sound']);
|
||||
}
|
||||
return \http_build_query($dataArray);
|
||||
}
|
||||
private function buildHeader(string $content) : string
|
||||
{
|
||||
$header = "POST /1/messages.json HTTP/1.1\r\n";
|
||||
$header .= "Host: api.pushover.net\r\n";
|
||||
$header .= "Content-Type: application/x-www-form-urlencoded\r\n";
|
||||
$header .= "Content-Length: " . \strlen($content) . "\r\n";
|
||||
$header .= "\r\n";
|
||||
return $header;
|
||||
}
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
foreach ($this->users as $user) {
|
||||
$this->user = $user;
|
||||
parent::write($record);
|
||||
$this->closeSocket();
|
||||
}
|
||||
$this->user = null;
|
||||
}
|
||||
/**
|
||||
* @param int|string $value
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $value
|
||||
*/
|
||||
public function setHighPriorityLevel($value) : self
|
||||
{
|
||||
$this->highPriorityLevel = Logger::toMonologLevel($value);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @param int|string $value
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $value
|
||||
*/
|
||||
public function setEmergencyLevel($value) : self
|
||||
{
|
||||
$this->emergencyLevel = Logger::toMonologLevel($value);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Use the formatted message?
|
||||
*/
|
||||
public function useFormattedMessage(bool $value) : self
|
||||
{
|
||||
$this->useFormattedMessage = $value;
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
91
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RedisHandler.php
vendored
Normal file
91
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RedisHandler.php
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Logs to a Redis key using rpush
|
||||
*
|
||||
* usage example:
|
||||
*
|
||||
* $log = new Logger('application');
|
||||
* $redis = new RedisHandler(new Predis\Client("tcp://localhost:6379"), "logs", "prod");
|
||||
* $log->pushHandler($redis);
|
||||
*
|
||||
* @author Thomas Tourlourat <thomas@tourlourat.com>
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class RedisHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var \Predis\Client<\Predis\Client>|\Redis */
|
||||
private $redisClient;
|
||||
/** @var string */
|
||||
private $redisKey;
|
||||
/** @var int */
|
||||
protected $capSize;
|
||||
/**
|
||||
* @param \Predis\Client<\Predis\Client>|\Redis $redis The redis instance
|
||||
* @param string $key The key name to push records to
|
||||
* @param int $capSize Number of entries to limit list size to, 0 = unlimited
|
||||
*/
|
||||
public function __construct($redis, string $key, $level = Logger::DEBUG, bool $bubble = \true, int $capSize = 0)
|
||||
{
|
||||
if (!($redis instanceof \DeliciousBrains\WP_Offload_Media\Gcp\Predis\Client || $redis instanceof \Redis)) {
|
||||
throw new \InvalidArgumentException('Predis\\Client or Redis instance required');
|
||||
}
|
||||
$this->redisClient = $redis;
|
||||
$this->redisKey = $key;
|
||||
$this->capSize = $capSize;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if ($this->capSize) {
|
||||
$this->writeCapped($record);
|
||||
} else {
|
||||
$this->redisClient->rpush($this->redisKey, $record["formatted"]);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Write and cap the collection
|
||||
* Writes the record to the redis list and caps its
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
protected function writeCapped(array $record) : void
|
||||
{
|
||||
if ($this->redisClient instanceof \Redis) {
|
||||
$mode = \defined('\\Redis::MULTI') ? \Redis::MULTI : 1;
|
||||
$this->redisClient->multi($mode)->rpush($this->redisKey, $record["formatted"])->ltrim($this->redisKey, -$this->capSize, -1)->exec();
|
||||
} else {
|
||||
$redisKey = $this->redisKey;
|
||||
$capSize = $this->capSize;
|
||||
$this->redisClient->transaction(function ($tx) use($record, $redisKey, $capSize) {
|
||||
$tx->rpush($redisKey, $record["formatted"]);
|
||||
$tx->ltrim($redisKey, -$capSize, -1);
|
||||
});
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter();
|
||||
}
|
||||
}
|
||||
61
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RedisPubSubHandler.php
vendored
Normal file
61
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RedisPubSubHandler.php
vendored
Normal file
@@ -0,0 +1,61 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Sends the message to a Redis Pub/Sub channel using PUBLISH
|
||||
*
|
||||
* usage example:
|
||||
*
|
||||
* $log = new Logger('application');
|
||||
* $redis = new RedisPubSubHandler(new Predis\Client("tcp://localhost:6379"), "logs", Logger::WARNING);
|
||||
* $log->pushHandler($redis);
|
||||
*
|
||||
* @author Gaëtan Faugère <gaetan@fauge.re>
|
||||
*/
|
||||
class RedisPubSubHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var \Predis\Client<\Predis\Client>|\Redis */
|
||||
private $redisClient;
|
||||
/** @var string */
|
||||
private $channelKey;
|
||||
/**
|
||||
* @param \Predis\Client<\Predis\Client>|\Redis $redis The redis instance
|
||||
* @param string $key The channel key to publish records to
|
||||
*/
|
||||
public function __construct($redis, string $key, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
if (!($redis instanceof \DeliciousBrains\WP_Offload_Media\Gcp\Predis\Client || $redis instanceof \Redis)) {
|
||||
throw new \InvalidArgumentException('Predis\\Client or Redis instance required');
|
||||
}
|
||||
$this->redisClient = $redis;
|
||||
$this->channelKey = $key;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->redisClient->publish($this->channelKey, $record["formatted"]);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new LineFormatter();
|
||||
}
|
||||
}
|
||||
102
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RollbarHandler.php
vendored
Normal file
102
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RollbarHandler.php
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Rollbar\RollbarLogger;
|
||||
use Throwable;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Sends errors to Rollbar
|
||||
*
|
||||
* If the context data contains a `payload` key, that is used as an array
|
||||
* of payload options to RollbarLogger's log method.
|
||||
*
|
||||
* Rollbar's context info will contain the context + extra keys from the log record
|
||||
* merged, and then on top of that a few keys:
|
||||
*
|
||||
* - level (rollbar level name)
|
||||
* - monolog_level (monolog level name, raw level, as rollbar only has 5 but monolog 8)
|
||||
* - channel
|
||||
* - datetime (unix timestamp)
|
||||
*
|
||||
* @author Paul Statezny <paulstatezny@gmail.com>
|
||||
*/
|
||||
class RollbarHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* @var RollbarLogger
|
||||
*/
|
||||
protected $rollbarLogger;
|
||||
/** @var string[] */
|
||||
protected $levelMap = [Logger::DEBUG => 'debug', Logger::INFO => 'info', Logger::NOTICE => 'info', Logger::WARNING => 'warning', Logger::ERROR => 'error', Logger::CRITICAL => 'critical', Logger::ALERT => 'critical', Logger::EMERGENCY => 'critical'];
|
||||
/**
|
||||
* Records whether any log records have been added since the last flush of the rollbar notifier
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
private $hasRecords = \false;
|
||||
/** @var bool */
|
||||
protected $initialized = \false;
|
||||
/**
|
||||
* @param RollbarLogger $rollbarLogger RollbarLogger object constructed with valid token
|
||||
*/
|
||||
public function __construct(RollbarLogger $rollbarLogger, $level = Logger::ERROR, bool $bubble = \true)
|
||||
{
|
||||
$this->rollbarLogger = $rollbarLogger;
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!$this->initialized) {
|
||||
// __destructor() doesn't get called on Fatal errors
|
||||
\register_shutdown_function(array($this, 'close'));
|
||||
$this->initialized = \true;
|
||||
}
|
||||
$context = $record['context'];
|
||||
$context = \array_merge($context, $record['extra'], ['level' => $this->levelMap[$record['level']], 'monolog_level' => $record['level_name'], 'channel' => $record['channel'], 'datetime' => $record['datetime']->format('U')]);
|
||||
if (isset($context['exception']) && $context['exception'] instanceof Throwable) {
|
||||
$exception = $context['exception'];
|
||||
unset($context['exception']);
|
||||
$toLog = $exception;
|
||||
} else {
|
||||
$toLog = $record['message'];
|
||||
}
|
||||
// @phpstan-ignore-next-line
|
||||
$this->rollbarLogger->log($context['level'], $toLog, $context);
|
||||
$this->hasRecords = \true;
|
||||
}
|
||||
public function flush() : void
|
||||
{
|
||||
if ($this->hasRecords) {
|
||||
$this->rollbarLogger->flush();
|
||||
$this->hasRecords = \false;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
$this->flush();
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
$this->flush();
|
||||
parent::reset();
|
||||
}
|
||||
}
|
||||
169
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RotatingFileHandler.php
vendored
Normal file
169
vendor/Gcp/monolog/monolog/src/Monolog/Handler/RotatingFileHandler.php
vendored
Normal file
@@ -0,0 +1,169 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use InvalidArgumentException;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Stores logs to files that are rotated every day and a limited number of files are kept.
|
||||
*
|
||||
* This rotation is only intended to be used as a workaround. Using logrotate to
|
||||
* handle the rotation is strongly encouraged when you can use it.
|
||||
*
|
||||
* @author Christophe Coevoet <stof@notk.org>
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*/
|
||||
class RotatingFileHandler extends StreamHandler
|
||||
{
|
||||
public const FILE_PER_DAY = 'Y-m-d';
|
||||
public const FILE_PER_MONTH = 'Y-m';
|
||||
public const FILE_PER_YEAR = 'Y';
|
||||
/** @var string */
|
||||
protected $filename;
|
||||
/** @var int */
|
||||
protected $maxFiles;
|
||||
/** @var bool */
|
||||
protected $mustRotate;
|
||||
/** @var \DateTimeImmutable */
|
||||
protected $nextRotation;
|
||||
/** @var string */
|
||||
protected $filenameFormat;
|
||||
/** @var string */
|
||||
protected $dateFormat;
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param int $maxFiles The maximal amount of files to keep (0 means unlimited)
|
||||
* @param int|null $filePermission Optional file permissions (default (0644) are only for owner read/write)
|
||||
* @param bool $useLocking Try to lock log file before doing any writes
|
||||
*/
|
||||
public function __construct(string $filename, int $maxFiles = 0, $level = Logger::DEBUG, bool $bubble = \true, ?int $filePermission = null, bool $useLocking = \false)
|
||||
{
|
||||
$this->filename = Utils::canonicalizePath($filename);
|
||||
$this->maxFiles = $maxFiles;
|
||||
$this->nextRotation = new \DateTimeImmutable('tomorrow');
|
||||
$this->filenameFormat = '{filename}-{date}';
|
||||
$this->dateFormat = static::FILE_PER_DAY;
|
||||
parent::__construct($this->getTimedFilename(), $level, $bubble, $filePermission, $useLocking);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
parent::close();
|
||||
if (\true === $this->mustRotate) {
|
||||
$this->rotate();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
parent::reset();
|
||||
if (\true === $this->mustRotate) {
|
||||
$this->rotate();
|
||||
}
|
||||
}
|
||||
public function setFilenameFormat(string $filenameFormat, string $dateFormat) : self
|
||||
{
|
||||
if (!\preg_match('{^[Yy](([/_.-]?m)([/_.-]?d)?)?$}', $dateFormat)) {
|
||||
throw new InvalidArgumentException('Invalid date format - format must be one of ' . 'RotatingFileHandler::FILE_PER_DAY ("Y-m-d"), RotatingFileHandler::FILE_PER_MONTH ("Y-m") ' . 'or RotatingFileHandler::FILE_PER_YEAR ("Y"), or you can set one of the ' . 'date formats using slashes, underscores and/or dots instead of dashes.');
|
||||
}
|
||||
if (\substr_count($filenameFormat, '{date}') === 0) {
|
||||
throw new InvalidArgumentException('Invalid filename format - format must contain at least `{date}`, because otherwise rotating is impossible.');
|
||||
}
|
||||
$this->filenameFormat = $filenameFormat;
|
||||
$this->dateFormat = $dateFormat;
|
||||
$this->url = $this->getTimedFilename();
|
||||
$this->close();
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
// on the first record written, if the log is new, we rotate (once per day) after the log has been written so that the new file exists
|
||||
if (null === $this->mustRotate) {
|
||||
$this->mustRotate = null === $this->url || !\file_exists($this->url);
|
||||
}
|
||||
// if the next rotation is expired, then we rotate immediately
|
||||
if ($this->nextRotation <= $record['datetime']) {
|
||||
$this->mustRotate = \true;
|
||||
$this->close();
|
||||
// triggers rotation
|
||||
}
|
||||
parent::write($record);
|
||||
if ($this->mustRotate) {
|
||||
$this->close();
|
||||
// triggers rotation
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Rotates the files.
|
||||
*/
|
||||
protected function rotate() : void
|
||||
{
|
||||
// update filename
|
||||
$this->url = $this->getTimedFilename();
|
||||
$this->nextRotation = new \DateTimeImmutable('tomorrow');
|
||||
$this->mustRotate = \false;
|
||||
// skip GC of old logs if files are unlimited
|
||||
if (0 === $this->maxFiles) {
|
||||
return;
|
||||
}
|
||||
$logFiles = \glob($this->getGlobPattern());
|
||||
if (\false === $logFiles) {
|
||||
// failed to glob
|
||||
return;
|
||||
}
|
||||
if ($this->maxFiles >= \count($logFiles)) {
|
||||
// no files to remove
|
||||
return;
|
||||
}
|
||||
// Sorting the files by name to remove the older ones
|
||||
\usort($logFiles, function ($a, $b) {
|
||||
return \strcmp($b, $a);
|
||||
});
|
||||
foreach (\array_slice($logFiles, $this->maxFiles) as $file) {
|
||||
if (\is_writable($file)) {
|
||||
// suppress errors here as unlink() might fail if two processes
|
||||
// are cleaning up/rotating at the same time
|
||||
\set_error_handler(function (int $errno, string $errstr, string $errfile, int $errline) : bool {
|
||||
return \false;
|
||||
});
|
||||
\unlink($file);
|
||||
\restore_error_handler();
|
||||
}
|
||||
}
|
||||
}
|
||||
protected function getTimedFilename() : string
|
||||
{
|
||||
$fileInfo = \pathinfo($this->filename);
|
||||
$timedFilename = \str_replace(['{filename}', '{date}'], [$fileInfo['filename'], \date($this->dateFormat)], $fileInfo['dirname'] . '/' . $this->filenameFormat);
|
||||
if (isset($fileInfo['extension'])) {
|
||||
$timedFilename .= '.' . $fileInfo['extension'];
|
||||
}
|
||||
return $timedFilename;
|
||||
}
|
||||
protected function getGlobPattern() : string
|
||||
{
|
||||
$fileInfo = \pathinfo($this->filename);
|
||||
$glob = \str_replace(['{filename}', '{date}'], [$fileInfo['filename'], \str_replace(['Y', 'y', 'm', 'd'], ['[0-9][0-9][0-9][0-9]', '[0-9][0-9]', '[0-9][0-9]', '[0-9][0-9]'], $this->dateFormat)], $fileInfo['dirname'] . '/' . $this->filenameFormat);
|
||||
if (isset($fileInfo['extension'])) {
|
||||
$glob .= '.' . $fileInfo['extension'];
|
||||
}
|
||||
return $glob;
|
||||
}
|
||||
}
|
||||
116
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SamplingHandler.php
vendored
Normal file
116
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SamplingHandler.php
vendored
Normal file
@@ -0,0 +1,116 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Sampling handler
|
||||
*
|
||||
* A sampled event stream can be useful for logging high frequency events in
|
||||
* a production environment where you only need an idea of what is happening
|
||||
* and are not concerned with capturing every occurrence. Since the decision to
|
||||
* handle or not handle a particular event is determined randomly, the
|
||||
* resulting sampled log is not guaranteed to contain 1/N of the events that
|
||||
* occurred in the application, but based on the Law of large numbers, it will
|
||||
* tend to be close to this ratio with a large number of attempts.
|
||||
*
|
||||
* @author Bryan Davis <bd808@wikimedia.org>
|
||||
* @author Kunal Mehta <legoktm@gmail.com>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
*/
|
||||
class SamplingHandler extends AbstractHandler implements ProcessableHandlerInterface, FormattableHandlerInterface
|
||||
{
|
||||
use ProcessableHandlerTrait;
|
||||
/**
|
||||
* @var HandlerInterface|callable
|
||||
* @phpstan-var HandlerInterface|callable(Record|array{level: Level}|null, HandlerInterface): HandlerInterface
|
||||
*/
|
||||
protected $handler;
|
||||
/**
|
||||
* @var int $factor
|
||||
*/
|
||||
protected $factor;
|
||||
/**
|
||||
* @psalm-param HandlerInterface|callable(Record|array{level: Level}|null, HandlerInterface): HandlerInterface $handler
|
||||
*
|
||||
* @param callable|HandlerInterface $handler Handler or factory callable($record|null, $samplingHandler).
|
||||
* @param int $factor Sample factor (e.g. 10 means every ~10th record is sampled)
|
||||
*/
|
||||
public function __construct($handler, int $factor)
|
||||
{
|
||||
parent::__construct();
|
||||
$this->handler = $handler;
|
||||
$this->factor = $factor;
|
||||
if (!$this->handler instanceof HandlerInterface && !\is_callable($this->handler)) {
|
||||
throw new \RuntimeException("The given handler (" . \json_encode($this->handler) . ") is not a callable nor a Monolog\\Handler\\HandlerInterface object");
|
||||
}
|
||||
}
|
||||
public function isHandling(array $record) : bool
|
||||
{
|
||||
return $this->getHandler($record)->isHandling($record);
|
||||
}
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($this->isHandling($record) && \mt_rand(1, $this->factor) === 1) {
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
$this->getHandler($record)->handle($record);
|
||||
}
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* Return the nested handler
|
||||
*
|
||||
* If the handler was provided as a factory callable, this will trigger the handler's instantiation.
|
||||
*
|
||||
* @phpstan-param Record|array{level: Level}|null $record
|
||||
*
|
||||
* @return HandlerInterface
|
||||
*/
|
||||
public function getHandler(?array $record = null)
|
||||
{
|
||||
if (!$this->handler instanceof HandlerInterface) {
|
||||
$this->handler = ($this->handler)($record, $this);
|
||||
if (!$this->handler instanceof HandlerInterface) {
|
||||
throw new \RuntimeException("The factory callable should return a HandlerInterface");
|
||||
}
|
||||
}
|
||||
return $this->handler;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
$handler = $this->getHandler();
|
||||
if ($handler instanceof FormattableHandlerInterface) {
|
||||
$handler->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($handler) . ' does not support formatters.');
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
$handler = $this->getHandler();
|
||||
if ($handler instanceof FormattableHandlerInterface) {
|
||||
return $handler->getFormatter();
|
||||
}
|
||||
throw new \UnexpectedValueException('The nested handler of type ' . \get_class($handler) . ' does not support formatters.');
|
||||
}
|
||||
}
|
||||
92
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SendGridHandler.php
vendored
Normal file
92
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SendGridHandler.php
vendored
Normal file
@@ -0,0 +1,92 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* SendGridrHandler uses the SendGrid API v2 function to send Log emails, more information in https://sendgrid.com/docs/API_Reference/Web_API/mail.html
|
||||
*
|
||||
* @author Ricardo Fontanelli <ricardo.fontanelli@hotmail.com>
|
||||
*/
|
||||
class SendGridHandler extends MailHandler
|
||||
{
|
||||
/**
|
||||
* The SendGrid API User
|
||||
* @var string
|
||||
*/
|
||||
protected $apiUser;
|
||||
/**
|
||||
* The SendGrid API Key
|
||||
* @var string
|
||||
*/
|
||||
protected $apiKey;
|
||||
/**
|
||||
* The email addresses to which the message will be sent
|
||||
* @var string
|
||||
*/
|
||||
protected $from;
|
||||
/**
|
||||
* The email addresses to which the message will be sent
|
||||
* @var string[]
|
||||
*/
|
||||
protected $to;
|
||||
/**
|
||||
* The subject of the email
|
||||
* @var string
|
||||
*/
|
||||
protected $subject;
|
||||
/**
|
||||
* @param string $apiUser The SendGrid API User
|
||||
* @param string $apiKey The SendGrid API Key
|
||||
* @param string $from The sender of the email
|
||||
* @param string|string[] $to The recipients of the email
|
||||
* @param string $subject The subject of the mail
|
||||
*/
|
||||
public function __construct(string $apiUser, string $apiKey, string $from, $to, string $subject, $level = Logger::ERROR, bool $bubble = \true)
|
||||
{
|
||||
if (!\extension_loaded('curl')) {
|
||||
throw new MissingExtensionException('The curl extension is needed to use the SendGridHandler');
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
$this->apiUser = $apiUser;
|
||||
$this->apiKey = $apiKey;
|
||||
$this->from = $from;
|
||||
$this->to = (array) $to;
|
||||
$this->subject = $subject;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function send(string $content, array $records) : void
|
||||
{
|
||||
$message = [];
|
||||
$message['api_user'] = $this->apiUser;
|
||||
$message['api_key'] = $this->apiKey;
|
||||
$message['from'] = $this->from;
|
||||
foreach ($this->to as $recipient) {
|
||||
$message['to[]'] = $recipient;
|
||||
}
|
||||
$message['subject'] = $this->subject;
|
||||
$message['date'] = \date('r');
|
||||
if ($this->isHtmlBody($content)) {
|
||||
$message['html'] = $content;
|
||||
} else {
|
||||
$message['text'] = $content;
|
||||
}
|
||||
$ch = \curl_init();
|
||||
\curl_setopt($ch, \CURLOPT_URL, 'https://api.sendgrid.com/api/mail.send.json');
|
||||
\curl_setopt($ch, \CURLOPT_POST, 1);
|
||||
\curl_setopt($ch, \CURLOPT_RETURNTRANSFER, 1);
|
||||
\curl_setopt($ch, \CURLOPT_POSTFIELDS, \http_build_query($message));
|
||||
Curl\Util::execute($ch, 2);
|
||||
}
|
||||
}
|
||||
293
vendor/Gcp/monolog/monolog/src/Monolog/Handler/Slack/SlackRecord.php
vendored
Normal file
293
vendor/Gcp/monolog/monolog/src/Monolog/Handler/Slack/SlackRecord.php
vendored
Normal file
@@ -0,0 +1,293 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\Slack;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\NormalizerFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
/**
|
||||
* Slack record utility helping to log to Slack webhooks or API.
|
||||
*
|
||||
* @author Greg Kedzierski <greg@gregkedzierski.com>
|
||||
* @author Haralan Dobrev <hkdobrev@gmail.com>
|
||||
* @see https://api.slack.com/incoming-webhooks
|
||||
* @see https://api.slack.com/docs/message-attachments
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from \Monolog\Handler\AbstractProcessingHandler
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class SlackRecord
|
||||
{
|
||||
public const COLOR_DANGER = 'danger';
|
||||
public const COLOR_WARNING = 'warning';
|
||||
public const COLOR_GOOD = 'good';
|
||||
public const COLOR_DEFAULT = '#e3e4e6';
|
||||
/**
|
||||
* Slack channel (encoded ID or name)
|
||||
* @var string|null
|
||||
*/
|
||||
private $channel;
|
||||
/**
|
||||
* Name of a bot
|
||||
* @var string|null
|
||||
*/
|
||||
private $username;
|
||||
/**
|
||||
* User icon e.g. 'ghost', 'http://example.com/user.png'
|
||||
* @var string|null
|
||||
*/
|
||||
private $userIcon;
|
||||
/**
|
||||
* Whether the message should be added to Slack as attachment (plain text otherwise)
|
||||
* @var bool
|
||||
*/
|
||||
private $useAttachment;
|
||||
/**
|
||||
* Whether the the context/extra messages added to Slack as attachments are in a short style
|
||||
* @var bool
|
||||
*/
|
||||
private $useShortAttachment;
|
||||
/**
|
||||
* Whether the attachment should include context and extra data
|
||||
* @var bool
|
||||
*/
|
||||
private $includeContextAndExtra;
|
||||
/**
|
||||
* Dot separated list of fields to exclude from slack message. E.g. ['context.field1', 'extra.field2']
|
||||
* @var string[]
|
||||
*/
|
||||
private $excludeFields;
|
||||
/**
|
||||
* @var ?FormatterInterface
|
||||
*/
|
||||
private $formatter;
|
||||
/**
|
||||
* @var NormalizerFormatter
|
||||
*/
|
||||
private $normalizerFormatter;
|
||||
/**
|
||||
* @param string[] $excludeFields
|
||||
*/
|
||||
public function __construct(?string $channel = null, ?string $username = null, bool $useAttachment = \true, ?string $userIcon = null, bool $useShortAttachment = \false, bool $includeContextAndExtra = \false, array $excludeFields = array(), ?FormatterInterface $formatter = null)
|
||||
{
|
||||
$this->setChannel($channel)->setUsername($username)->useAttachment($useAttachment)->setUserIcon($userIcon)->useShortAttachment($useShortAttachment)->includeContextAndExtra($includeContextAndExtra)->excludeFields($excludeFields)->setFormatter($formatter);
|
||||
if ($this->includeContextAndExtra) {
|
||||
$this->normalizerFormatter = new NormalizerFormatter();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Returns required data in format that Slack
|
||||
* is expecting.
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
* @phpstan-return mixed[]
|
||||
*/
|
||||
public function getSlackData(array $record) : array
|
||||
{
|
||||
$dataArray = array();
|
||||
$record = $this->removeExcludedFields($record);
|
||||
if ($this->username) {
|
||||
$dataArray['username'] = $this->username;
|
||||
}
|
||||
if ($this->channel) {
|
||||
$dataArray['channel'] = $this->channel;
|
||||
}
|
||||
if ($this->formatter && !$this->useAttachment) {
|
||||
/** @phpstan-ignore-next-line */
|
||||
$message = $this->formatter->format($record);
|
||||
} else {
|
||||
$message = $record['message'];
|
||||
}
|
||||
if ($this->useAttachment) {
|
||||
$attachment = array('fallback' => $message, 'text' => $message, 'color' => $this->getAttachmentColor($record['level']), 'fields' => array(), 'mrkdwn_in' => array('fields'), 'ts' => $record['datetime']->getTimestamp(), 'footer' => $this->username, 'footer_icon' => $this->userIcon);
|
||||
if ($this->useShortAttachment) {
|
||||
$attachment['title'] = $record['level_name'];
|
||||
} else {
|
||||
$attachment['title'] = 'Message';
|
||||
$attachment['fields'][] = $this->generateAttachmentField('Level', $record['level_name']);
|
||||
}
|
||||
if ($this->includeContextAndExtra) {
|
||||
foreach (array('extra', 'context') as $key) {
|
||||
if (empty($record[$key])) {
|
||||
continue;
|
||||
}
|
||||
if ($this->useShortAttachment) {
|
||||
$attachment['fields'][] = $this->generateAttachmentField((string) $key, $record[$key]);
|
||||
} else {
|
||||
// Add all extra fields as individual fields in attachment
|
||||
$attachment['fields'] = \array_merge($attachment['fields'], $this->generateAttachmentFields($record[$key]));
|
||||
}
|
||||
}
|
||||
}
|
||||
$dataArray['attachments'] = array($attachment);
|
||||
} else {
|
||||
$dataArray['text'] = $message;
|
||||
}
|
||||
if ($this->userIcon) {
|
||||
if (\filter_var($this->userIcon, \FILTER_VALIDATE_URL)) {
|
||||
$dataArray['icon_url'] = $this->userIcon;
|
||||
} else {
|
||||
$dataArray['icon_emoji'] = ":{$this->userIcon}:";
|
||||
}
|
||||
}
|
||||
return $dataArray;
|
||||
}
|
||||
/**
|
||||
* Returns a Slack message attachment color associated with
|
||||
* provided level.
|
||||
*/
|
||||
public function getAttachmentColor(int $level) : string
|
||||
{
|
||||
switch (\true) {
|
||||
case $level >= Logger::ERROR:
|
||||
return static::COLOR_DANGER;
|
||||
case $level >= Logger::WARNING:
|
||||
return static::COLOR_WARNING;
|
||||
case $level >= Logger::INFO:
|
||||
return static::COLOR_GOOD;
|
||||
default:
|
||||
return static::COLOR_DEFAULT;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Stringifies an array of key/value pairs to be used in attachment fields
|
||||
*
|
||||
* @param mixed[] $fields
|
||||
*/
|
||||
public function stringify(array $fields) : string
|
||||
{
|
||||
/** @var Record $fields */
|
||||
$normalized = $this->normalizerFormatter->format($fields);
|
||||
$hasSecondDimension = \count(\array_filter($normalized, 'is_array'));
|
||||
$hasNonNumericKeys = !\count(\array_filter(\array_keys($normalized), 'is_numeric'));
|
||||
return $hasSecondDimension || $hasNonNumericKeys ? Utils::jsonEncode($normalized, \JSON_PRETTY_PRINT | Utils::DEFAULT_JSON_FLAGS) : Utils::jsonEncode($normalized, Utils::DEFAULT_JSON_FLAGS);
|
||||
}
|
||||
/**
|
||||
* Channel used by the bot when posting
|
||||
*
|
||||
* @param ?string $channel
|
||||
*
|
||||
* @return static
|
||||
*/
|
||||
public function setChannel(?string $channel = null) : self
|
||||
{
|
||||
$this->channel = $channel;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Username used by the bot when posting
|
||||
*
|
||||
* @param ?string $username
|
||||
*
|
||||
* @return static
|
||||
*/
|
||||
public function setUsername(?string $username = null) : self
|
||||
{
|
||||
$this->username = $username;
|
||||
return $this;
|
||||
}
|
||||
public function useAttachment(bool $useAttachment = \true) : self
|
||||
{
|
||||
$this->useAttachment = $useAttachment;
|
||||
return $this;
|
||||
}
|
||||
public function setUserIcon(?string $userIcon = null) : self
|
||||
{
|
||||
$this->userIcon = $userIcon;
|
||||
if (\is_string($userIcon)) {
|
||||
$this->userIcon = \trim($userIcon, ':');
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
public function useShortAttachment(bool $useShortAttachment = \false) : self
|
||||
{
|
||||
$this->useShortAttachment = $useShortAttachment;
|
||||
return $this;
|
||||
}
|
||||
public function includeContextAndExtra(bool $includeContextAndExtra = \false) : self
|
||||
{
|
||||
$this->includeContextAndExtra = $includeContextAndExtra;
|
||||
if ($this->includeContextAndExtra) {
|
||||
$this->normalizerFormatter = new NormalizerFormatter();
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @param string[] $excludeFields
|
||||
*/
|
||||
public function excludeFields(array $excludeFields = []) : self
|
||||
{
|
||||
$this->excludeFields = $excludeFields;
|
||||
return $this;
|
||||
}
|
||||
public function setFormatter(?FormatterInterface $formatter = null) : self
|
||||
{
|
||||
$this->formatter = $formatter;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Generates attachment field
|
||||
*
|
||||
* @param string|mixed[] $value
|
||||
*
|
||||
* @return array{title: string, value: string, short: false}
|
||||
*/
|
||||
private function generateAttachmentField(string $title, $value) : array
|
||||
{
|
||||
$value = \is_array($value) ? \sprintf('```%s```', \substr($this->stringify($value), 0, 1990)) : $value;
|
||||
return array('title' => \ucfirst($title), 'value' => $value, 'short' => \false);
|
||||
}
|
||||
/**
|
||||
* Generates a collection of attachment fields from array
|
||||
*
|
||||
* @param mixed[] $data
|
||||
*
|
||||
* @return array<array{title: string, value: string, short: false}>
|
||||
*/
|
||||
private function generateAttachmentFields(array $data) : array
|
||||
{
|
||||
/** @var Record $data */
|
||||
$normalized = $this->normalizerFormatter->format($data);
|
||||
$fields = array();
|
||||
foreach ($normalized as $key => $value) {
|
||||
$fields[] = $this->generateAttachmentField((string) $key, $value);
|
||||
}
|
||||
return $fields;
|
||||
}
|
||||
/**
|
||||
* Get a copy of record with fields excluded according to $this->excludeFields
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
private function removeExcludedFields(array $record) : array
|
||||
{
|
||||
foreach ($this->excludeFields as $field) {
|
||||
$keys = \explode('.', $field);
|
||||
$node =& $record;
|
||||
$lastKey = \end($keys);
|
||||
foreach ($keys as $key) {
|
||||
if (!isset($node[$key])) {
|
||||
break;
|
||||
}
|
||||
if ($lastKey === $key) {
|
||||
unset($node[$key]);
|
||||
break;
|
||||
}
|
||||
$node =& $node[$key];
|
||||
}
|
||||
}
|
||||
return $record;
|
||||
}
|
||||
}
|
||||
187
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SlackHandler.php
vendored
Normal file
187
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SlackHandler.php
vendored
Normal file
@@ -0,0 +1,187 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\Slack\SlackRecord;
|
||||
/**
|
||||
* Sends notifications through Slack API
|
||||
*
|
||||
* @author Greg Kedzierski <greg@gregkedzierski.com>
|
||||
* @see https://api.slack.com/
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class SlackHandler extends SocketHandler
|
||||
{
|
||||
/**
|
||||
* Slack API token
|
||||
* @var string
|
||||
*/
|
||||
private $token;
|
||||
/**
|
||||
* Instance of the SlackRecord util class preparing data for Slack API.
|
||||
* @var SlackRecord
|
||||
*/
|
||||
private $slackRecord;
|
||||
/**
|
||||
* @param string $token Slack API token
|
||||
* @param string $channel Slack channel (encoded ID or name)
|
||||
* @param string|null $username Name of a bot
|
||||
* @param bool $useAttachment Whether the message should be added to Slack as attachment (plain text otherwise)
|
||||
* @param string|null $iconEmoji The emoji name to use (or null)
|
||||
* @param bool $useShortAttachment Whether the context/extra messages added to Slack as attachments are in a short style
|
||||
* @param bool $includeContextAndExtra Whether the attachment should include context and extra data
|
||||
* @param string[] $excludeFields Dot separated list of fields to exclude from slack message. E.g. ['context.field1', 'extra.field2']
|
||||
* @throws MissingExtensionException If no OpenSSL PHP extension configured
|
||||
*/
|
||||
public function __construct(string $token, string $channel, ?string $username = null, bool $useAttachment = \true, ?string $iconEmoji = null, $level = Logger::CRITICAL, bool $bubble = \true, bool $useShortAttachment = \false, bool $includeContextAndExtra = \false, array $excludeFields = array(), bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
if (!\extension_loaded('openssl')) {
|
||||
throw new MissingExtensionException('The OpenSSL PHP extension is required to use the SlackHandler');
|
||||
}
|
||||
parent::__construct('ssl://slack.com:443', $level, $bubble, $persistent, $timeout, $writingTimeout, $connectionTimeout, $chunkSize);
|
||||
$this->slackRecord = new SlackRecord($channel, $username, $useAttachment, $iconEmoji, $useShortAttachment, $includeContextAndExtra, $excludeFields);
|
||||
$this->token = $token;
|
||||
}
|
||||
public function getSlackRecord() : SlackRecord
|
||||
{
|
||||
return $this->slackRecord;
|
||||
}
|
||||
public function getToken() : string
|
||||
{
|
||||
return $this->token;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
$content = $this->buildContent($record);
|
||||
return $this->buildHeader($content) . $content;
|
||||
}
|
||||
/**
|
||||
* Builds the body of API call
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
private function buildContent(array $record) : string
|
||||
{
|
||||
$dataArray = $this->prepareContentData($record);
|
||||
return \http_build_query($dataArray);
|
||||
}
|
||||
/**
|
||||
* @phpstan-param FormattedRecord $record
|
||||
* @return string[]
|
||||
*/
|
||||
protected function prepareContentData(array $record) : array
|
||||
{
|
||||
$dataArray = $this->slackRecord->getSlackData($record);
|
||||
$dataArray['token'] = $this->token;
|
||||
if (!empty($dataArray['attachments'])) {
|
||||
$dataArray['attachments'] = Utils::jsonEncode($dataArray['attachments']);
|
||||
}
|
||||
return $dataArray;
|
||||
}
|
||||
/**
|
||||
* Builds the header of the API Call
|
||||
*/
|
||||
private function buildHeader(string $content) : string
|
||||
{
|
||||
$header = "POST /api/chat.postMessage HTTP/1.1\r\n";
|
||||
$header .= "Host: slack.com\r\n";
|
||||
$header .= "Content-Type: application/x-www-form-urlencoded\r\n";
|
||||
$header .= "Content-Length: " . \strlen($content) . "\r\n";
|
||||
$header .= "\r\n";
|
||||
return $header;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
parent::write($record);
|
||||
$this->finalizeWrite();
|
||||
}
|
||||
/**
|
||||
* Finalizes the request by reading some bytes and then closing the socket
|
||||
*
|
||||
* If we do not read some but close the socket too early, slack sometimes
|
||||
* drops the request entirely.
|
||||
*/
|
||||
protected function finalizeWrite() : void
|
||||
{
|
||||
$res = $this->getResource();
|
||||
if (\is_resource($res)) {
|
||||
@\fread($res, 2048);
|
||||
}
|
||||
$this->closeSocket();
|
||||
}
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
parent::setFormatter($formatter);
|
||||
$this->slackRecord->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
$formatter = parent::getFormatter();
|
||||
$this->slackRecord->setFormatter($formatter);
|
||||
return $formatter;
|
||||
}
|
||||
/**
|
||||
* Channel used by the bot when posting
|
||||
*/
|
||||
public function setChannel(string $channel) : self
|
||||
{
|
||||
$this->slackRecord->setChannel($channel);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Username used by the bot when posting
|
||||
*/
|
||||
public function setUsername(string $username) : self
|
||||
{
|
||||
$this->slackRecord->setUsername($username);
|
||||
return $this;
|
||||
}
|
||||
public function useAttachment(bool $useAttachment) : self
|
||||
{
|
||||
$this->slackRecord->useAttachment($useAttachment);
|
||||
return $this;
|
||||
}
|
||||
public function setIconEmoji(string $iconEmoji) : self
|
||||
{
|
||||
$this->slackRecord->setUserIcon($iconEmoji);
|
||||
return $this;
|
||||
}
|
||||
public function useShortAttachment(bool $useShortAttachment) : self
|
||||
{
|
||||
$this->slackRecord->useShortAttachment($useShortAttachment);
|
||||
return $this;
|
||||
}
|
||||
public function includeContextAndExtra(bool $includeContextAndExtra) : self
|
||||
{
|
||||
$this->slackRecord->includeContextAndExtra($includeContextAndExtra);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @param string[] $excludeFields
|
||||
*/
|
||||
public function excludeFields(array $excludeFields) : self
|
||||
{
|
||||
$this->slackRecord->excludeFields($excludeFields);
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
90
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SlackWebhookHandler.php
vendored
Normal file
90
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SlackWebhookHandler.php
vendored
Normal file
@@ -0,0 +1,90 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\Slack\SlackRecord;
|
||||
/**
|
||||
* Sends notifications through Slack Webhooks
|
||||
*
|
||||
* @author Haralan Dobrev <hkdobrev@gmail.com>
|
||||
* @see https://api.slack.com/incoming-webhooks
|
||||
*/
|
||||
class SlackWebhookHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* Slack Webhook token
|
||||
* @var string
|
||||
*/
|
||||
private $webhookUrl;
|
||||
/**
|
||||
* Instance of the SlackRecord util class preparing data for Slack API.
|
||||
* @var SlackRecord
|
||||
*/
|
||||
private $slackRecord;
|
||||
/**
|
||||
* @param string $webhookUrl Slack Webhook URL
|
||||
* @param string|null $channel Slack channel (encoded ID or name)
|
||||
* @param string|null $username Name of a bot
|
||||
* @param bool $useAttachment Whether the message should be added to Slack as attachment (plain text otherwise)
|
||||
* @param string|null $iconEmoji The emoji name to use (or null)
|
||||
* @param bool $useShortAttachment Whether the the context/extra messages added to Slack as attachments are in a short style
|
||||
* @param bool $includeContextAndExtra Whether the attachment should include context and extra data
|
||||
* @param string[] $excludeFields Dot separated list of fields to exclude from slack message. E.g. ['context.field1', 'extra.field2']
|
||||
*/
|
||||
public function __construct(string $webhookUrl, ?string $channel = null, ?string $username = null, bool $useAttachment = \true, ?string $iconEmoji = null, bool $useShortAttachment = \false, bool $includeContextAndExtra = \false, $level = Logger::CRITICAL, bool $bubble = \true, array $excludeFields = array())
|
||||
{
|
||||
if (!\extension_loaded('curl')) {
|
||||
throw new MissingExtensionException('The curl extension is needed to use the SlackWebhookHandler');
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
$this->webhookUrl = $webhookUrl;
|
||||
$this->slackRecord = new SlackRecord($channel, $username, $useAttachment, $iconEmoji, $useShortAttachment, $includeContextAndExtra, $excludeFields);
|
||||
}
|
||||
public function getSlackRecord() : SlackRecord
|
||||
{
|
||||
return $this->slackRecord;
|
||||
}
|
||||
public function getWebhookUrl() : string
|
||||
{
|
||||
return $this->webhookUrl;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$postData = $this->slackRecord->getSlackData($record);
|
||||
$postString = Utils::jsonEncode($postData);
|
||||
$ch = \curl_init();
|
||||
$options = array(\CURLOPT_URL => $this->webhookUrl, \CURLOPT_POST => \true, \CURLOPT_RETURNTRANSFER => \true, \CURLOPT_HTTPHEADER => array('Content-type: application/json'), \CURLOPT_POSTFIELDS => $postString);
|
||||
if (\defined('CURLOPT_SAFE_UPLOAD')) {
|
||||
$options[\CURLOPT_SAFE_UPLOAD] = \true;
|
||||
}
|
||||
\curl_setopt_array($ch, $options);
|
||||
Curl\Util::execute($ch);
|
||||
}
|
||||
public function setFormatter(FormatterInterface $formatter) : HandlerInterface
|
||||
{
|
||||
parent::setFormatter($formatter);
|
||||
$this->slackRecord->setFormatter($formatter);
|
||||
return $this;
|
||||
}
|
||||
public function getFormatter() : FormatterInterface
|
||||
{
|
||||
$formatter = parent::getFormatter();
|
||||
$this->slackRecord->setFormatter($formatter);
|
||||
return $formatter;
|
||||
}
|
||||
}
|
||||
388
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SocketHandler.php
vendored
Normal file
388
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SocketHandler.php
vendored
Normal file
@@ -0,0 +1,388 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Stores to any socket - uses fsockopen() or pfsockopen().
|
||||
*
|
||||
* @author Pablo de Leon Belloc <pablolb@gmail.com>
|
||||
* @see http://php.net/manual/en/function.fsockopen.php
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class SocketHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var string */
|
||||
private $connectionString;
|
||||
/** @var float */
|
||||
private $connectionTimeout;
|
||||
/** @var resource|null */
|
||||
private $resource;
|
||||
/** @var float */
|
||||
private $timeout;
|
||||
/** @var float */
|
||||
private $writingTimeout;
|
||||
/** @var ?int */
|
||||
private $lastSentBytes = null;
|
||||
/** @var ?int */
|
||||
private $chunkSize;
|
||||
/** @var bool */
|
||||
private $persistent;
|
||||
/** @var ?int */
|
||||
private $errno = null;
|
||||
/** @var ?string */
|
||||
private $errstr = null;
|
||||
/** @var ?float */
|
||||
private $lastWritingAt = null;
|
||||
/**
|
||||
* @param string $connectionString Socket connection string
|
||||
* @param bool $persistent Flag to enable/disable persistent connections
|
||||
* @param float $timeout Socket timeout to wait until the request is being aborted
|
||||
* @param float $writingTimeout Socket timeout to wait until the request should've been sent/written
|
||||
* @param float|null $connectionTimeout Socket connect timeout to wait until the connection should've been
|
||||
* established
|
||||
* @param int|null $chunkSize Sets the chunk size. Only has effect during connection in the writing cycle
|
||||
*
|
||||
* @throws \InvalidArgumentException If an invalid timeout value (less than 0) is passed.
|
||||
*/
|
||||
public function __construct(string $connectionString, $level = Logger::DEBUG, bool $bubble = \true, bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->connectionString = $connectionString;
|
||||
if ($connectionTimeout !== null) {
|
||||
$this->validateTimeout($connectionTimeout);
|
||||
}
|
||||
$this->connectionTimeout = $connectionTimeout ?? (float) \ini_get('default_socket_timeout');
|
||||
$this->persistent = $persistent;
|
||||
$this->validateTimeout($timeout);
|
||||
$this->timeout = $timeout;
|
||||
$this->validateTimeout($writingTimeout);
|
||||
$this->writingTimeout = $writingTimeout;
|
||||
$this->chunkSize = $chunkSize;
|
||||
}
|
||||
/**
|
||||
* Connect (if necessary) and write to the socket
|
||||
*
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @throws \UnexpectedValueException
|
||||
* @throws \RuntimeException
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->connectIfNotConnected();
|
||||
$data = $this->generateDataStream($record);
|
||||
$this->writeToSocket($data);
|
||||
}
|
||||
/**
|
||||
* We will not close a PersistentSocket instance so it can be reused in other requests.
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
if (!$this->isPersistent()) {
|
||||
$this->closeSocket();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Close socket, if open
|
||||
*/
|
||||
public function closeSocket() : void
|
||||
{
|
||||
if (\is_resource($this->resource)) {
|
||||
\fclose($this->resource);
|
||||
$this->resource = null;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Set socket connection to be persistent. It only has effect before the connection is initiated.
|
||||
*/
|
||||
public function setPersistent(bool $persistent) : self
|
||||
{
|
||||
$this->persistent = $persistent;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Set connection timeout. Only has effect before we connect.
|
||||
*
|
||||
* @see http://php.net/manual/en/function.fsockopen.php
|
||||
*/
|
||||
public function setConnectionTimeout(float $seconds) : self
|
||||
{
|
||||
$this->validateTimeout($seconds);
|
||||
$this->connectionTimeout = $seconds;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Set write timeout. Only has effect before we connect.
|
||||
*
|
||||
* @see http://php.net/manual/en/function.stream-set-timeout.php
|
||||
*/
|
||||
public function setTimeout(float $seconds) : self
|
||||
{
|
||||
$this->validateTimeout($seconds);
|
||||
$this->timeout = $seconds;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Set writing timeout. Only has effect during connection in the writing cycle.
|
||||
*
|
||||
* @param float $seconds 0 for no timeout
|
||||
*/
|
||||
public function setWritingTimeout(float $seconds) : self
|
||||
{
|
||||
$this->validateTimeout($seconds);
|
||||
$this->writingTimeout = $seconds;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Set chunk size. Only has effect during connection in the writing cycle.
|
||||
*/
|
||||
public function setChunkSize(int $bytes) : self
|
||||
{
|
||||
$this->chunkSize = $bytes;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Get current connection string
|
||||
*/
|
||||
public function getConnectionString() : string
|
||||
{
|
||||
return $this->connectionString;
|
||||
}
|
||||
/**
|
||||
* Get persistent setting
|
||||
*/
|
||||
public function isPersistent() : bool
|
||||
{
|
||||
return $this->persistent;
|
||||
}
|
||||
/**
|
||||
* Get current connection timeout setting
|
||||
*/
|
||||
public function getConnectionTimeout() : float
|
||||
{
|
||||
return $this->connectionTimeout;
|
||||
}
|
||||
/**
|
||||
* Get current in-transfer timeout
|
||||
*/
|
||||
public function getTimeout() : float
|
||||
{
|
||||
return $this->timeout;
|
||||
}
|
||||
/**
|
||||
* Get current local writing timeout
|
||||
*
|
||||
* @return float
|
||||
*/
|
||||
public function getWritingTimeout() : float
|
||||
{
|
||||
return $this->writingTimeout;
|
||||
}
|
||||
/**
|
||||
* Get current chunk size
|
||||
*/
|
||||
public function getChunkSize() : ?int
|
||||
{
|
||||
return $this->chunkSize;
|
||||
}
|
||||
/**
|
||||
* Check to see if the socket is currently available.
|
||||
*
|
||||
* UDP might appear to be connected but might fail when writing. See http://php.net/fsockopen for details.
|
||||
*/
|
||||
public function isConnected() : bool
|
||||
{
|
||||
return \is_resource($this->resource) && !\feof($this->resource);
|
||||
// on TCP - other party can close connection.
|
||||
}
|
||||
/**
|
||||
* Wrapper to allow mocking
|
||||
*
|
||||
* @return resource|false
|
||||
*/
|
||||
protected function pfsockopen()
|
||||
{
|
||||
return @\pfsockopen($this->connectionString, -1, $this->errno, $this->errstr, $this->connectionTimeout);
|
||||
}
|
||||
/**
|
||||
* Wrapper to allow mocking
|
||||
*
|
||||
* @return resource|false
|
||||
*/
|
||||
protected function fsockopen()
|
||||
{
|
||||
return @\fsockopen($this->connectionString, -1, $this->errno, $this->errstr, $this->connectionTimeout);
|
||||
}
|
||||
/**
|
||||
* Wrapper to allow mocking
|
||||
*
|
||||
* @see http://php.net/manual/en/function.stream-set-timeout.php
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
protected function streamSetTimeout()
|
||||
{
|
||||
$seconds = \floor($this->timeout);
|
||||
$microseconds = \round(($this->timeout - $seconds) * 1000000.0);
|
||||
if (!\is_resource($this->resource)) {
|
||||
throw new \LogicException('streamSetTimeout called but $this->resource is not a resource');
|
||||
}
|
||||
return \stream_set_timeout($this->resource, (int) $seconds, (int) $microseconds);
|
||||
}
|
||||
/**
|
||||
* Wrapper to allow mocking
|
||||
*
|
||||
* @see http://php.net/manual/en/function.stream-set-chunk-size.php
|
||||
*
|
||||
* @return int|bool
|
||||
*/
|
||||
protected function streamSetChunkSize()
|
||||
{
|
||||
if (!\is_resource($this->resource)) {
|
||||
throw new \LogicException('streamSetChunkSize called but $this->resource is not a resource');
|
||||
}
|
||||
if (null === $this->chunkSize) {
|
||||
throw new \LogicException('streamSetChunkSize called but $this->chunkSize is not set');
|
||||
}
|
||||
return \stream_set_chunk_size($this->resource, $this->chunkSize);
|
||||
}
|
||||
/**
|
||||
* Wrapper to allow mocking
|
||||
*
|
||||
* @return int|bool
|
||||
*/
|
||||
protected function fwrite(string $data)
|
||||
{
|
||||
if (!\is_resource($this->resource)) {
|
||||
throw new \LogicException('fwrite called but $this->resource is not a resource');
|
||||
}
|
||||
return @\fwrite($this->resource, $data);
|
||||
}
|
||||
/**
|
||||
* Wrapper to allow mocking
|
||||
*
|
||||
* @return mixed[]|bool
|
||||
*/
|
||||
protected function streamGetMetadata()
|
||||
{
|
||||
if (!\is_resource($this->resource)) {
|
||||
throw new \LogicException('streamGetMetadata called but $this->resource is not a resource');
|
||||
}
|
||||
return \stream_get_meta_data($this->resource);
|
||||
}
|
||||
private function validateTimeout(float $value) : void
|
||||
{
|
||||
if ($value < 0) {
|
||||
throw new \InvalidArgumentException("Timeout must be 0 or a positive float (got {$value})");
|
||||
}
|
||||
}
|
||||
private function connectIfNotConnected() : void
|
||||
{
|
||||
if ($this->isConnected()) {
|
||||
return;
|
||||
}
|
||||
$this->connect();
|
||||
}
|
||||
/**
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
protected function generateDataStream(array $record) : string
|
||||
{
|
||||
return (string) $record['formatted'];
|
||||
}
|
||||
/**
|
||||
* @return resource|null
|
||||
*/
|
||||
protected function getResource()
|
||||
{
|
||||
return $this->resource;
|
||||
}
|
||||
private function connect() : void
|
||||
{
|
||||
$this->createSocketResource();
|
||||
$this->setSocketTimeout();
|
||||
$this->setStreamChunkSize();
|
||||
}
|
||||
private function createSocketResource() : void
|
||||
{
|
||||
if ($this->isPersistent()) {
|
||||
$resource = $this->pfsockopen();
|
||||
} else {
|
||||
$resource = $this->fsockopen();
|
||||
}
|
||||
if (\is_bool($resource)) {
|
||||
throw new \UnexpectedValueException("Failed connecting to {$this->connectionString} ({$this->errno}: {$this->errstr})");
|
||||
}
|
||||
$this->resource = $resource;
|
||||
}
|
||||
private function setSocketTimeout() : void
|
||||
{
|
||||
if (!$this->streamSetTimeout()) {
|
||||
throw new \UnexpectedValueException("Failed setting timeout with stream_set_timeout()");
|
||||
}
|
||||
}
|
||||
private function setStreamChunkSize() : void
|
||||
{
|
||||
if ($this->chunkSize && !$this->streamSetChunkSize()) {
|
||||
throw new \UnexpectedValueException("Failed setting chunk size with stream_set_chunk_size()");
|
||||
}
|
||||
}
|
||||
private function writeToSocket(string $data) : void
|
||||
{
|
||||
$length = \strlen($data);
|
||||
$sent = 0;
|
||||
$this->lastSentBytes = $sent;
|
||||
while ($this->isConnected() && $sent < $length) {
|
||||
if (0 == $sent) {
|
||||
$chunk = $this->fwrite($data);
|
||||
} else {
|
||||
$chunk = $this->fwrite(\substr($data, $sent));
|
||||
}
|
||||
if ($chunk === \false) {
|
||||
throw new \RuntimeException("Could not write to socket");
|
||||
}
|
||||
$sent += $chunk;
|
||||
$socketInfo = $this->streamGetMetadata();
|
||||
if (\is_array($socketInfo) && $socketInfo['timed_out']) {
|
||||
throw new \RuntimeException("Write timed-out");
|
||||
}
|
||||
if ($this->writingIsTimedOut($sent)) {
|
||||
throw new \RuntimeException("Write timed-out, no data sent for `{$this->writingTimeout}` seconds, probably we got disconnected (sent {$sent} of {$length})");
|
||||
}
|
||||
}
|
||||
if (!$this->isConnected() && $sent < $length) {
|
||||
throw new \RuntimeException("End-of-file reached, probably we got disconnected (sent {$sent} of {$length})");
|
||||
}
|
||||
}
|
||||
private function writingIsTimedOut(int $sent) : bool
|
||||
{
|
||||
// convert to ms
|
||||
if (0.0 == $this->writingTimeout) {
|
||||
return \false;
|
||||
}
|
||||
if ($sent !== $this->lastSentBytes) {
|
||||
$this->lastWritingAt = \microtime(\true);
|
||||
$this->lastSentBytes = $sent;
|
||||
return \false;
|
||||
} else {
|
||||
\usleep(100);
|
||||
}
|
||||
if (\microtime(\true) - $this->lastWritingAt >= $this->writingTimeout) {
|
||||
$this->closeSocket();
|
||||
return \true;
|
||||
}
|
||||
return \false;
|
||||
}
|
||||
}
|
||||
52
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SqsHandler.php
vendored
Normal file
52
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SqsHandler.php
vendored
Normal file
@@ -0,0 +1,52 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Aws\Sqs\SqsClient;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Writes to any sqs queue.
|
||||
*
|
||||
* @author Martijn van Calker <git@amvc.nl>
|
||||
*/
|
||||
class SqsHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** 256 KB in bytes - maximum message size in SQS */
|
||||
protected const MAX_MESSAGE_SIZE = 262144;
|
||||
/** 100 KB in bytes - head message size for new error log */
|
||||
protected const HEAD_MESSAGE_SIZE = 102400;
|
||||
/** @var SqsClient */
|
||||
private $client;
|
||||
/** @var string */
|
||||
private $queueUrl;
|
||||
public function __construct(SqsClient $sqsClient, string $queueUrl, $level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->client = $sqsClient;
|
||||
$this->queueUrl = $queueUrl;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!isset($record['formatted']) || 'string' !== \gettype($record['formatted'])) {
|
||||
throw new \InvalidArgumentException('SqsHandler accepts only formatted records as a string' . Utils::getRecordMessageForException($record));
|
||||
}
|
||||
$messageBody = $record['formatted'];
|
||||
if (\strlen($messageBody) >= static::MAX_MESSAGE_SIZE) {
|
||||
$messageBody = Utils::substr($messageBody, 0, static::HEAD_MESSAGE_SIZE);
|
||||
}
|
||||
$this->client->sendMessage(['QueueUrl' => $this->queueUrl, 'MessageBody' => $messageBody]);
|
||||
}
|
||||
}
|
||||
230
vendor/Gcp/monolog/monolog/src/Monolog/Handler/StreamHandler.php
vendored
Normal file
230
vendor/Gcp/monolog/monolog/src/Monolog/Handler/StreamHandler.php
vendored
Normal file
@@ -0,0 +1,230 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Stores to any stream resource
|
||||
*
|
||||
* Can be used to store into php://stderr, remote and local files, etc.
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class StreamHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @const int */
|
||||
protected const MAX_CHUNK_SIZE = 2147483647;
|
||||
/** @const int 10MB */
|
||||
protected const DEFAULT_CHUNK_SIZE = 10 * 1024 * 1024;
|
||||
/** @var int */
|
||||
protected $streamChunkSize;
|
||||
/** @var resource|null */
|
||||
protected $stream;
|
||||
/** @var ?string */
|
||||
protected $url = null;
|
||||
/** @var ?string */
|
||||
private $errorMessage = null;
|
||||
/** @var ?int */
|
||||
protected $filePermission;
|
||||
/** @var bool */
|
||||
protected $useLocking;
|
||||
/** @var string */
|
||||
protected $fileOpenMode;
|
||||
/** @var true|null */
|
||||
private $dirCreated = null;
|
||||
/** @var bool */
|
||||
private $retrying = \false;
|
||||
/**
|
||||
* @param resource|string $stream If a missing path can't be created, an UnexpectedValueException will be thrown on first write
|
||||
* @param int|null $filePermission Optional file permissions (default (0644) are only for owner read/write)
|
||||
* @param bool $useLocking Try to lock log file before doing any writes
|
||||
* @param string $fileOpenMode The fopen() mode used when opening a file, if $stream is a file path
|
||||
*
|
||||
* @throws \InvalidArgumentException If stream is not a resource or string
|
||||
*/
|
||||
public function __construct($stream, $level = Logger::DEBUG, bool $bubble = \true, ?int $filePermission = null, bool $useLocking = \false, $fileOpenMode = 'a')
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
if (($phpMemoryLimit = Utils::expandIniShorthandBytes(\ini_get('memory_limit'))) !== \false) {
|
||||
if ($phpMemoryLimit > 0) {
|
||||
// use max 10% of allowed memory for the chunk size, and at least 100KB
|
||||
$this->streamChunkSize = \min(static::MAX_CHUNK_SIZE, \max((int) ($phpMemoryLimit / 10), 100 * 1024));
|
||||
} else {
|
||||
// memory is unlimited, set to the default 10MB
|
||||
$this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
|
||||
}
|
||||
} else {
|
||||
// no memory limit information, set to the default 10MB
|
||||
$this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
|
||||
}
|
||||
if (\is_resource($stream)) {
|
||||
$this->stream = $stream;
|
||||
\stream_set_chunk_size($this->stream, $this->streamChunkSize);
|
||||
} elseif (\is_string($stream)) {
|
||||
$this->url = Utils::canonicalizePath($stream);
|
||||
} else {
|
||||
throw new \InvalidArgumentException('A stream must either be a resource or a string.');
|
||||
}
|
||||
$this->fileOpenMode = $fileOpenMode;
|
||||
$this->filePermission = $filePermission;
|
||||
$this->useLocking = $useLocking;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
if ($this->url && \is_resource($this->stream)) {
|
||||
\fclose($this->stream);
|
||||
}
|
||||
$this->stream = null;
|
||||
$this->dirCreated = null;
|
||||
}
|
||||
/**
|
||||
* Return the currently active stream if it is open
|
||||
*
|
||||
* @return resource|null
|
||||
*/
|
||||
public function getStream()
|
||||
{
|
||||
return $this->stream;
|
||||
}
|
||||
/**
|
||||
* Return the stream URL if it was configured with a URL and not an active resource
|
||||
*
|
||||
* @return string|null
|
||||
*/
|
||||
public function getUrl() : ?string
|
||||
{
|
||||
return $this->url;
|
||||
}
|
||||
/**
|
||||
* @return int
|
||||
*/
|
||||
public function getStreamChunkSize() : int
|
||||
{
|
||||
return $this->streamChunkSize;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!\is_resource($this->stream)) {
|
||||
$url = $this->url;
|
||||
if (null === $url || '' === $url) {
|
||||
throw new \LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().' . Utils::getRecordMessageForException($record));
|
||||
}
|
||||
$this->createDir($url);
|
||||
$this->errorMessage = null;
|
||||
\set_error_handler(function (...$args) {
|
||||
return $this->customErrorHandler(...$args);
|
||||
});
|
||||
try {
|
||||
$stream = \fopen($url, $this->fileOpenMode);
|
||||
if ($this->filePermission !== null) {
|
||||
@\chmod($url, $this->filePermission);
|
||||
}
|
||||
} finally {
|
||||
\restore_error_handler();
|
||||
}
|
||||
if (!\is_resource($stream)) {
|
||||
$this->stream = null;
|
||||
throw new \UnexpectedValueException(\sprintf('The stream or file "%s" could not be opened in append mode: ' . $this->errorMessage, $url) . Utils::getRecordMessageForException($record));
|
||||
}
|
||||
\stream_set_chunk_size($stream, $this->streamChunkSize);
|
||||
$this->stream = $stream;
|
||||
}
|
||||
$stream = $this->stream;
|
||||
if (!\is_resource($stream)) {
|
||||
throw new \LogicException('No stream was opened yet' . Utils::getRecordMessageForException($record));
|
||||
}
|
||||
if ($this->useLocking) {
|
||||
// ignoring errors here, there's not much we can do about them
|
||||
\flock($stream, \LOCK_EX);
|
||||
}
|
||||
$this->errorMessage = null;
|
||||
\set_error_handler(function (...$args) {
|
||||
return $this->customErrorHandler(...$args);
|
||||
});
|
||||
try {
|
||||
$this->streamWrite($stream, $record);
|
||||
} finally {
|
||||
\restore_error_handler();
|
||||
}
|
||||
if ($this->errorMessage !== null) {
|
||||
$error = $this->errorMessage;
|
||||
// close the resource if possible to reopen it, and retry the failed write
|
||||
if (!$this->retrying && $this->url !== null && $this->url !== 'php://memory') {
|
||||
$this->retrying = \true;
|
||||
$this->close();
|
||||
$this->write($record);
|
||||
return;
|
||||
}
|
||||
throw new \UnexpectedValueException('Writing to the log file failed: ' . $error . Utils::getRecordMessageForException($record));
|
||||
}
|
||||
$this->retrying = \false;
|
||||
if ($this->useLocking) {
|
||||
\flock($stream, \LOCK_UN);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Write to stream
|
||||
* @param resource $stream
|
||||
* @param array $record
|
||||
*
|
||||
* @phpstan-param FormattedRecord $record
|
||||
*/
|
||||
protected function streamWrite($stream, array $record) : void
|
||||
{
|
||||
\fwrite($stream, (string) $record['formatted']);
|
||||
}
|
||||
private function customErrorHandler(int $code, string $msg) : bool
|
||||
{
|
||||
$this->errorMessage = \preg_replace('{^(fopen|mkdir|fwrite)\\(.*?\\): }', '', $msg);
|
||||
return \true;
|
||||
}
|
||||
private function getDirFromStream(string $stream) : ?string
|
||||
{
|
||||
$pos = \strpos($stream, '://');
|
||||
if ($pos === \false) {
|
||||
return \dirname($stream);
|
||||
}
|
||||
if ('file://' === \substr($stream, 0, 7)) {
|
||||
return \dirname(\substr($stream, 7));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
private function createDir(string $url) : void
|
||||
{
|
||||
// Do not try to create dir if it has already been tried.
|
||||
if ($this->dirCreated) {
|
||||
return;
|
||||
}
|
||||
$dir = $this->getDirFromStream($url);
|
||||
if (null !== $dir && !\is_dir($dir)) {
|
||||
$this->errorMessage = null;
|
||||
\set_error_handler(function (...$args) {
|
||||
return $this->customErrorHandler(...$args);
|
||||
});
|
||||
$status = \mkdir($dir, 0777, \true);
|
||||
\restore_error_handler();
|
||||
if (\false === $status && !\is_dir($dir) && \strpos((string) $this->errorMessage, 'File exists') === \false) {
|
||||
throw new \UnexpectedValueException(\sprintf('There is no existing directory at "%s" and it could not be created: ' . $this->errorMessage, $dir));
|
||||
}
|
||||
}
|
||||
$this->dirCreated = \true;
|
||||
}
|
||||
}
|
||||
103
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SwiftMailerHandler.php
vendored
Normal file
103
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SwiftMailerHandler.php
vendored
Normal file
@@ -0,0 +1,103 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Swift_Message;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Swift;
|
||||
/**
|
||||
* SwiftMailerHandler uses Swift_Mailer to send the emails
|
||||
*
|
||||
* @author Gyula Sallai
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @deprecated Since Monolog 2.6. Use SymfonyMailerHandler instead.
|
||||
*/
|
||||
class SwiftMailerHandler extends MailHandler
|
||||
{
|
||||
/** @var \Swift_Mailer */
|
||||
protected $mailer;
|
||||
/** @var Swift_Message|callable(string, Record[]): Swift_Message */
|
||||
private $messageTemplate;
|
||||
/**
|
||||
* @psalm-param Swift_Message|callable(string, Record[]): Swift_Message $message
|
||||
*
|
||||
* @param \Swift_Mailer $mailer The mailer to use
|
||||
* @param callable|Swift_Message $message An example message for real messages, only the body will be replaced
|
||||
*/
|
||||
public function __construct(\DeliciousBrains\WP_Offload_Media\Gcp\Swift_Mailer $mailer, $message, $level = Logger::ERROR, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
@\trigger_error('The SwiftMailerHandler is deprecated since Monolog 2.6. Use SymfonyMailerHandler instead.', \E_USER_DEPRECATED);
|
||||
$this->mailer = $mailer;
|
||||
$this->messageTemplate = $message;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function send(string $content, array $records) : void
|
||||
{
|
||||
$this->mailer->send($this->buildMessage($content, $records));
|
||||
}
|
||||
/**
|
||||
* Gets the formatter for the Swift_Message subject.
|
||||
*
|
||||
* @param string|null $format The format of the subject
|
||||
*/
|
||||
protected function getSubjectFormatter(?string $format) : FormatterInterface
|
||||
{
|
||||
return new LineFormatter($format);
|
||||
}
|
||||
/**
|
||||
* Creates instance of Swift_Message to be sent
|
||||
*
|
||||
* @param string $content formatted email body to be sent
|
||||
* @param array $records Log records that formed the content
|
||||
* @return Swift_Message
|
||||
*
|
||||
* @phpstan-param Record[] $records
|
||||
*/
|
||||
protected function buildMessage(string $content, array $records) : Swift_Message
|
||||
{
|
||||
$message = null;
|
||||
if ($this->messageTemplate instanceof Swift_Message) {
|
||||
$message = clone $this->messageTemplate;
|
||||
$message->generateId();
|
||||
} elseif (\is_callable($this->messageTemplate)) {
|
||||
$message = ($this->messageTemplate)($content, $records);
|
||||
}
|
||||
if (!$message instanceof Swift_Message) {
|
||||
$record = \reset($records);
|
||||
throw new \InvalidArgumentException('Could not resolve message as instance of Swift_Message or a callable returning it' . ($record ? Utils::getRecordMessageForException($record) : ''));
|
||||
}
|
||||
if ($records) {
|
||||
$subjectFormatter = $this->getSubjectFormatter($message->getSubject());
|
||||
$message->setSubject($subjectFormatter->format($this->getHighestRecord($records)));
|
||||
}
|
||||
$mime = 'text/plain';
|
||||
if ($this->isHtmlBody($content)) {
|
||||
$mime = 'text/html';
|
||||
}
|
||||
$message->setBody($content, $mime);
|
||||
/** @phpstan-ignore-next-line */
|
||||
if (\version_compare(Swift::VERSION, '6.0.0', '>=')) {
|
||||
$message->setDate(new \DateTimeImmutable());
|
||||
} else {
|
||||
/** @phpstan-ignore-next-line */
|
||||
$message->setDate(\time());
|
||||
}
|
||||
return $message;
|
||||
}
|
||||
}
|
||||
101
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SymfonyMailerHandler.php
vendored
Normal file
101
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SymfonyMailerHandler.php
vendored
Normal file
@@ -0,0 +1,101 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\LineFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Symfony\Component\Mailer\MailerInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Symfony\Component\Mailer\Transport\TransportInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Symfony\Component\Mime\Email;
|
||||
/**
|
||||
* SymfonyMailerHandler uses Symfony's Mailer component to send the emails
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class SymfonyMailerHandler extends MailHandler
|
||||
{
|
||||
/** @var MailerInterface|TransportInterface */
|
||||
protected $mailer;
|
||||
/** @var Email|callable(string, Record[]): Email */
|
||||
private $emailTemplate;
|
||||
/**
|
||||
* @psalm-param Email|callable(string, Record[]): Email $email
|
||||
*
|
||||
* @param MailerInterface|TransportInterface $mailer The mailer to use
|
||||
* @param callable|Email $email An email template, the subject/body will be replaced
|
||||
*/
|
||||
public function __construct($mailer, $email, $level = Logger::ERROR, bool $bubble = \true)
|
||||
{
|
||||
parent::__construct($level, $bubble);
|
||||
$this->mailer = $mailer;
|
||||
$this->emailTemplate = $email;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function send(string $content, array $records) : void
|
||||
{
|
||||
$this->mailer->send($this->buildMessage($content, $records));
|
||||
}
|
||||
/**
|
||||
* Gets the formatter for the Swift_Message subject.
|
||||
*
|
||||
* @param string|null $format The format of the subject
|
||||
*/
|
||||
protected function getSubjectFormatter(?string $format) : FormatterInterface
|
||||
{
|
||||
return new LineFormatter($format);
|
||||
}
|
||||
/**
|
||||
* Creates instance of Email to be sent
|
||||
*
|
||||
* @param string $content formatted email body to be sent
|
||||
* @param array $records Log records that formed the content
|
||||
*
|
||||
* @phpstan-param Record[] $records
|
||||
*/
|
||||
protected function buildMessage(string $content, array $records) : Email
|
||||
{
|
||||
$message = null;
|
||||
if ($this->emailTemplate instanceof Email) {
|
||||
$message = clone $this->emailTemplate;
|
||||
} elseif (\is_callable($this->emailTemplate)) {
|
||||
$message = ($this->emailTemplate)($content, $records);
|
||||
}
|
||||
if (!$message instanceof Email) {
|
||||
$record = \reset($records);
|
||||
throw new \InvalidArgumentException('Could not resolve message as instance of Email or a callable returning it' . ($record ? Utils::getRecordMessageForException($record) : ''));
|
||||
}
|
||||
if ($records) {
|
||||
$subjectFormatter = $this->getSubjectFormatter($message->getSubject());
|
||||
$message->subject($subjectFormatter->format($this->getHighestRecord($records)));
|
||||
}
|
||||
if ($this->isHtmlBody($content)) {
|
||||
if (null !== ($charset = $message->getHtmlCharset())) {
|
||||
$message->html($content, $charset);
|
||||
} else {
|
||||
$message->html($content);
|
||||
}
|
||||
} else {
|
||||
if (null !== ($charset = $message->getTextCharset())) {
|
||||
$message->text($content, $charset);
|
||||
} else {
|
||||
$message->text($content);
|
||||
}
|
||||
}
|
||||
return $message->date(new \DateTimeImmutable());
|
||||
}
|
||||
}
|
||||
63
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SyslogHandler.php
vendored
Normal file
63
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SyslogHandler.php
vendored
Normal file
@@ -0,0 +1,63 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Logs to syslog service.
|
||||
*
|
||||
* usage example:
|
||||
*
|
||||
* $log = new Logger('application');
|
||||
* $syslog = new SyslogHandler('myfacility', 'local6');
|
||||
* $formatter = new LineFormatter("%channel%.%level_name%: %message% %extra%");
|
||||
* $syslog->setFormatter($formatter);
|
||||
* $log->pushHandler($syslog);
|
||||
*
|
||||
* @author Sven Paulus <sven@karlsruhe.org>
|
||||
*/
|
||||
class SyslogHandler extends AbstractSyslogHandler
|
||||
{
|
||||
/** @var string */
|
||||
protected $ident;
|
||||
/** @var int */
|
||||
protected $logopts;
|
||||
/**
|
||||
* @param string $ident
|
||||
* @param string|int $facility Either one of the names of the keys in $this->facilities, or a LOG_* facility constant
|
||||
* @param int $logopts Option flags for the openlog() call, defaults to LOG_PID
|
||||
*/
|
||||
public function __construct(string $ident, $facility = \LOG_USER, $level = Logger::DEBUG, bool $bubble = \true, int $logopts = \LOG_PID)
|
||||
{
|
||||
parent::__construct($facility, $level, $bubble);
|
||||
$this->ident = $ident;
|
||||
$this->logopts = $logopts;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
\closelog();
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
if (!\openlog($this->ident, $this->logopts, $this->facility)) {
|
||||
throw new \LogicException('Can\'t open syslog for ident "' . $this->ident . '" and facility "' . $this->facility . '"' . Utils::getRecordMessageForException($record));
|
||||
}
|
||||
\syslog($this->logLevels[$record['level']], (string) $record['formatted']);
|
||||
}
|
||||
}
|
||||
76
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SyslogUdp/UdpSocket.php
vendored
Normal file
76
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SyslogUdp/UdpSocket.php
vendored
Normal file
@@ -0,0 +1,76 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\SyslogUdp;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
use Socket;
|
||||
class UdpSocket
|
||||
{
|
||||
protected const DATAGRAM_MAX_LENGTH = 65023;
|
||||
/** @var string */
|
||||
protected $ip;
|
||||
/** @var int */
|
||||
protected $port;
|
||||
/** @var resource|Socket|null */
|
||||
protected $socket = null;
|
||||
public function __construct(string $ip, int $port = 514)
|
||||
{
|
||||
$this->ip = $ip;
|
||||
$this->port = $port;
|
||||
}
|
||||
/**
|
||||
* @param string $line
|
||||
* @param string $header
|
||||
* @return void
|
||||
*/
|
||||
public function write($line, $header = "")
|
||||
{
|
||||
$this->send($this->assembleMessage($line, $header));
|
||||
}
|
||||
public function close() : void
|
||||
{
|
||||
if (\is_resource($this->socket) || $this->socket instanceof Socket) {
|
||||
\socket_close($this->socket);
|
||||
$this->socket = null;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @return resource|Socket
|
||||
*/
|
||||
protected function getSocket()
|
||||
{
|
||||
if (null !== $this->socket) {
|
||||
return $this->socket;
|
||||
}
|
||||
$domain = \AF_INET;
|
||||
$protocol = \SOL_UDP;
|
||||
// Check if we are using unix sockets.
|
||||
if ($this->port === 0) {
|
||||
$domain = \AF_UNIX;
|
||||
$protocol = \IPPROTO_IP;
|
||||
}
|
||||
$this->socket = \socket_create($domain, \SOCK_DGRAM, $protocol) ?: null;
|
||||
if (null === $this->socket) {
|
||||
throw new \RuntimeException('The UdpSocket to ' . $this->ip . ':' . $this->port . ' could not be opened via socket_create');
|
||||
}
|
||||
return $this->socket;
|
||||
}
|
||||
protected function send(string $chunk) : void
|
||||
{
|
||||
\socket_sendto($this->getSocket(), $chunk, \strlen($chunk), $flags = 0, $this->ip, $this->port);
|
||||
}
|
||||
protected function assembleMessage(string $line, string $header) : string
|
||||
{
|
||||
$chunkSize = static::DATAGRAM_MAX_LENGTH - \strlen($header);
|
||||
return $header . Utils::substr($line, 0, $chunkSize);
|
||||
}
|
||||
}
|
||||
116
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SyslogUdpHandler.php
vendored
Normal file
116
vendor/Gcp/monolog/monolog/src/Monolog/Handler/SyslogUdpHandler.php
vendored
Normal file
@@ -0,0 +1,116 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DateTimeInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\SyslogUdp\UdpSocket;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* A Handler for logging to a remote syslogd server.
|
||||
*
|
||||
* @author Jesper Skovgaard Nielsen <nulpunkt@gmail.com>
|
||||
* @author Dominik Kukacka <dominik.kukacka@gmail.com>
|
||||
*/
|
||||
class SyslogUdpHandler extends AbstractSyslogHandler
|
||||
{
|
||||
const RFC3164 = 0;
|
||||
const RFC5424 = 1;
|
||||
const RFC5424e = 2;
|
||||
/** @var array<self::RFC*, string> */
|
||||
private $dateFormats = array(self::RFC3164 => 'M d H:i:s', self::RFC5424 => \DateTime::RFC3339, self::RFC5424e => \DateTime::RFC3339_EXTENDED);
|
||||
/** @var UdpSocket */
|
||||
protected $socket;
|
||||
/** @var string */
|
||||
protected $ident;
|
||||
/** @var self::RFC* */
|
||||
protected $rfc;
|
||||
/**
|
||||
* @param string $host Either IP/hostname or a path to a unix socket (port must be 0 then)
|
||||
* @param int $port Port number, or 0 if $host is a unix socket
|
||||
* @param string|int $facility Either one of the names of the keys in $this->facilities, or a LOG_* facility constant
|
||||
* @param bool $bubble Whether the messages that are handled can bubble up the stack or not
|
||||
* @param string $ident Program name or tag for each log message.
|
||||
* @param int $rfc RFC to format the message for.
|
||||
* @throws MissingExtensionException
|
||||
*
|
||||
* @phpstan-param self::RFC* $rfc
|
||||
*/
|
||||
public function __construct(string $host, int $port = 514, $facility = \LOG_USER, $level = Logger::DEBUG, bool $bubble = \true, string $ident = 'php', int $rfc = self::RFC5424)
|
||||
{
|
||||
if (!\extension_loaded('sockets')) {
|
||||
throw new MissingExtensionException('The sockets extension is required to use the SyslogUdpHandler');
|
||||
}
|
||||
parent::__construct($facility, $level, $bubble);
|
||||
$this->ident = $ident;
|
||||
$this->rfc = $rfc;
|
||||
$this->socket = new UdpSocket($host, $port);
|
||||
}
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$lines = $this->splitMessageIntoLines($record['formatted']);
|
||||
$header = $this->makeCommonSyslogHeader($this->logLevels[$record['level']], $record['datetime']);
|
||||
foreach ($lines as $line) {
|
||||
$this->socket->write($line, $header);
|
||||
}
|
||||
}
|
||||
public function close() : void
|
||||
{
|
||||
$this->socket->close();
|
||||
}
|
||||
/**
|
||||
* @param string|string[] $message
|
||||
* @return string[]
|
||||
*/
|
||||
private function splitMessageIntoLines($message) : array
|
||||
{
|
||||
if (\is_array($message)) {
|
||||
$message = \implode("\n", $message);
|
||||
}
|
||||
$lines = \preg_split('/$\\R?^/m', (string) $message, -1, \PREG_SPLIT_NO_EMPTY);
|
||||
if (\false === $lines) {
|
||||
$pcreErrorCode = \preg_last_error();
|
||||
throw new \RuntimeException('Could not preg_split: ' . $pcreErrorCode . ' / ' . Utils::pcreLastErrorMessage($pcreErrorCode));
|
||||
}
|
||||
return $lines;
|
||||
}
|
||||
/**
|
||||
* Make common syslog header (see rfc5424 or rfc3164)
|
||||
*/
|
||||
protected function makeCommonSyslogHeader(int $severity, DateTimeInterface $datetime) : string
|
||||
{
|
||||
$priority = $severity + $this->facility;
|
||||
if (!($pid = \getmypid())) {
|
||||
$pid = '-';
|
||||
}
|
||||
if (!($hostname = \gethostname())) {
|
||||
$hostname = '-';
|
||||
}
|
||||
if ($this->rfc === self::RFC3164) {
|
||||
// see https://github.com/phpstan/phpstan/issues/5348
|
||||
// @phpstan-ignore-next-line
|
||||
$dateNew = $datetime->setTimezone(new \DateTimeZone('UTC'));
|
||||
$date = $dateNew->format($this->dateFormats[$this->rfc]);
|
||||
return "<{$priority}>" . $date . " " . $hostname . " " . $this->ident . "[" . $pid . "]: ";
|
||||
}
|
||||
$date = $datetime->format($this->dateFormats[$this->rfc]);
|
||||
return "<{$priority}>1 " . $date . " " . $hostname . " " . $this->ident . " " . $pid . " - - ";
|
||||
}
|
||||
/**
|
||||
* Inject your own socket, mainly used for testing
|
||||
*/
|
||||
public function setSocket(UdpSocket $socket) : self
|
||||
{
|
||||
$this->socket = $socket;
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
216
vendor/Gcp/monolog/monolog/src/Monolog/Handler/TelegramBotHandler.php
vendored
Normal file
216
vendor/Gcp/monolog/monolog/src/Monolog/Handler/TelegramBotHandler.php
vendored
Normal file
@@ -0,0 +1,216 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use RuntimeException;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Utils;
|
||||
/**
|
||||
* Handler send logs to Telegram using Telegram Bot API.
|
||||
*
|
||||
* How to use:
|
||||
* 1) Create telegram bot with https://telegram.me/BotFather
|
||||
* 2) Create a telegram channel where logs will be recorded.
|
||||
* 3) Add created bot from step 1 to the created channel from step 2.
|
||||
*
|
||||
* Use telegram bot API key from step 1 and channel name with '@' prefix from step 2 to create instance of TelegramBotHandler
|
||||
*
|
||||
* @link https://core.telegram.org/bots/api
|
||||
*
|
||||
* @author Mazur Alexandr <alexandrmazur96@gmail.com>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class TelegramBotHandler extends AbstractProcessingHandler
|
||||
{
|
||||
private const BOT_API = 'https://api.telegram.org/bot';
|
||||
/**
|
||||
* The available values of parseMode according to the Telegram api documentation
|
||||
*/
|
||||
private const AVAILABLE_PARSE_MODES = ['HTML', 'MarkdownV2', 'Markdown'];
|
||||
/**
|
||||
* The maximum number of characters allowed in a message according to the Telegram api documentation
|
||||
*/
|
||||
private const MAX_MESSAGE_LENGTH = 4096;
|
||||
/**
|
||||
* Telegram bot access token provided by BotFather.
|
||||
* Create telegram bot with https://telegram.me/BotFather and use access token from it.
|
||||
* @var string
|
||||
*/
|
||||
private $apiKey;
|
||||
/**
|
||||
* Telegram channel name.
|
||||
* Since to start with '@' symbol as prefix.
|
||||
* @var string
|
||||
*/
|
||||
private $channel;
|
||||
/**
|
||||
* The kind of formatting that is used for the message.
|
||||
* See available options at https://core.telegram.org/bots/api#formatting-options
|
||||
* or in AVAILABLE_PARSE_MODES
|
||||
* @var ?string
|
||||
*/
|
||||
private $parseMode;
|
||||
/**
|
||||
* Disables link previews for links in the message.
|
||||
* @var ?bool
|
||||
*/
|
||||
private $disableWebPagePreview;
|
||||
/**
|
||||
* Sends the message silently. Users will receive a notification with no sound.
|
||||
* @var ?bool
|
||||
*/
|
||||
private $disableNotification;
|
||||
/**
|
||||
* True - split a message longer than MAX_MESSAGE_LENGTH into parts and send in multiple messages.
|
||||
* False - truncates a message that is too long.
|
||||
* @var bool
|
||||
*/
|
||||
private $splitLongMessages;
|
||||
/**
|
||||
* Adds 1-second delay between sending a split message (according to Telegram API to avoid 429 Too Many Requests).
|
||||
* @var bool
|
||||
*/
|
||||
private $delayBetweenMessages;
|
||||
/**
|
||||
* @param string $apiKey Telegram bot access token provided by BotFather
|
||||
* @param string $channel Telegram channel name
|
||||
* @param bool $splitLongMessages Split a message longer than MAX_MESSAGE_LENGTH into parts and send in multiple messages
|
||||
* @param bool $delayBetweenMessages Adds delay between sending a split message according to Telegram API
|
||||
* @throws MissingExtensionException
|
||||
*/
|
||||
public function __construct(string $apiKey, string $channel, $level = Logger::DEBUG, bool $bubble = \true, ?string $parseMode = null, ?bool $disableWebPagePreview = null, ?bool $disableNotification = null, bool $splitLongMessages = \false, bool $delayBetweenMessages = \false)
|
||||
{
|
||||
if (!\extension_loaded('curl')) {
|
||||
throw new MissingExtensionException('The curl extension is needed to use the TelegramBotHandler');
|
||||
}
|
||||
parent::__construct($level, $bubble);
|
||||
$this->apiKey = $apiKey;
|
||||
$this->channel = $channel;
|
||||
$this->setParseMode($parseMode);
|
||||
$this->disableWebPagePreview($disableWebPagePreview);
|
||||
$this->disableNotification($disableNotification);
|
||||
$this->splitLongMessages($splitLongMessages);
|
||||
$this->delayBetweenMessages($delayBetweenMessages);
|
||||
}
|
||||
public function setParseMode(?string $parseMode = null) : self
|
||||
{
|
||||
if ($parseMode !== null && !\in_array($parseMode, self::AVAILABLE_PARSE_MODES)) {
|
||||
throw new \InvalidArgumentException('Unknown parseMode, use one of these: ' . \implode(', ', self::AVAILABLE_PARSE_MODES) . '.');
|
||||
}
|
||||
$this->parseMode = $parseMode;
|
||||
return $this;
|
||||
}
|
||||
public function disableWebPagePreview(?bool $disableWebPagePreview = null) : self
|
||||
{
|
||||
$this->disableWebPagePreview = $disableWebPagePreview;
|
||||
return $this;
|
||||
}
|
||||
public function disableNotification(?bool $disableNotification = null) : self
|
||||
{
|
||||
$this->disableNotification = $disableNotification;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* True - split a message longer than MAX_MESSAGE_LENGTH into parts and send in multiple messages.
|
||||
* False - truncates a message that is too long.
|
||||
* @param bool $splitLongMessages
|
||||
* @return $this
|
||||
*/
|
||||
public function splitLongMessages(bool $splitLongMessages = \false) : self
|
||||
{
|
||||
$this->splitLongMessages = $splitLongMessages;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Adds 1-second delay between sending a split message (according to Telegram API to avoid 429 Too Many Requests).
|
||||
* @param bool $delayBetweenMessages
|
||||
* @return $this
|
||||
*/
|
||||
public function delayBetweenMessages(bool $delayBetweenMessages = \false) : self
|
||||
{
|
||||
$this->delayBetweenMessages = $delayBetweenMessages;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
/** @var Record[] $messages */
|
||||
$messages = [];
|
||||
foreach ($records as $record) {
|
||||
if (!$this->isHandling($record)) {
|
||||
continue;
|
||||
}
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
$messages[] = $record;
|
||||
}
|
||||
if (!empty($messages)) {
|
||||
$this->send((string) $this->getFormatter()->formatBatch($messages));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->send($record['formatted']);
|
||||
}
|
||||
/**
|
||||
* Send request to @link https://api.telegram.org/bot on SendMessage action.
|
||||
* @param string $message
|
||||
*/
|
||||
protected function send(string $message) : void
|
||||
{
|
||||
$messages = $this->handleMessageLength($message);
|
||||
foreach ($messages as $key => $msg) {
|
||||
if ($this->delayBetweenMessages && $key > 0) {
|
||||
\sleep(1);
|
||||
}
|
||||
$this->sendCurl($msg);
|
||||
}
|
||||
}
|
||||
protected function sendCurl(string $message) : void
|
||||
{
|
||||
$ch = \curl_init();
|
||||
$url = self::BOT_API . $this->apiKey . '/SendMessage';
|
||||
\curl_setopt($ch, \CURLOPT_URL, $url);
|
||||
\curl_setopt($ch, \CURLOPT_RETURNTRANSFER, \true);
|
||||
\curl_setopt($ch, \CURLOPT_SSL_VERIFYPEER, \true);
|
||||
\curl_setopt($ch, \CURLOPT_POSTFIELDS, \http_build_query(['text' => $message, 'chat_id' => $this->channel, 'parse_mode' => $this->parseMode, 'disable_web_page_preview' => $this->disableWebPagePreview, 'disable_notification' => $this->disableNotification]));
|
||||
$result = Curl\Util::execute($ch);
|
||||
if (!\is_string($result)) {
|
||||
throw new RuntimeException('Telegram API error. Description: No response');
|
||||
}
|
||||
$result = \json_decode($result, \true);
|
||||
if ($result['ok'] === \false) {
|
||||
throw new RuntimeException('Telegram API error. Description: ' . $result['description']);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Handle a message that is too long: truncates or splits into several
|
||||
* @param string $message
|
||||
* @return string[]
|
||||
*/
|
||||
private function handleMessageLength(string $message) : array
|
||||
{
|
||||
$truncatedMarker = ' (...truncated)';
|
||||
if (!$this->splitLongMessages && \strlen($message) > self::MAX_MESSAGE_LENGTH) {
|
||||
return [Utils::substr($message, 0, self::MAX_MESSAGE_LENGTH - \strlen($truncatedMarker)) . $truncatedMarker];
|
||||
}
|
||||
return \str_split($message, self::MAX_MESSAGE_LENGTH);
|
||||
}
|
||||
}
|
||||
212
vendor/Gcp/monolog/monolog/src/Monolog/Handler/TestHandler.php
vendored
Normal file
212
vendor/Gcp/monolog/monolog/src/Monolog/Handler/TestHandler.php
vendored
Normal file
@@ -0,0 +1,212 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
/**
|
||||
* Used for testing purposes.
|
||||
*
|
||||
* It records all records and gives you access to them for verification.
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @method bool hasEmergency($record)
|
||||
* @method bool hasAlert($record)
|
||||
* @method bool hasCritical($record)
|
||||
* @method bool hasError($record)
|
||||
* @method bool hasWarning($record)
|
||||
* @method bool hasNotice($record)
|
||||
* @method bool hasInfo($record)
|
||||
* @method bool hasDebug($record)
|
||||
*
|
||||
* @method bool hasEmergencyRecords()
|
||||
* @method bool hasAlertRecords()
|
||||
* @method bool hasCriticalRecords()
|
||||
* @method bool hasErrorRecords()
|
||||
* @method bool hasWarningRecords()
|
||||
* @method bool hasNoticeRecords()
|
||||
* @method bool hasInfoRecords()
|
||||
* @method bool hasDebugRecords()
|
||||
*
|
||||
* @method bool hasEmergencyThatContains($message)
|
||||
* @method bool hasAlertThatContains($message)
|
||||
* @method bool hasCriticalThatContains($message)
|
||||
* @method bool hasErrorThatContains($message)
|
||||
* @method bool hasWarningThatContains($message)
|
||||
* @method bool hasNoticeThatContains($message)
|
||||
* @method bool hasInfoThatContains($message)
|
||||
* @method bool hasDebugThatContains($message)
|
||||
*
|
||||
* @method bool hasEmergencyThatMatches($message)
|
||||
* @method bool hasAlertThatMatches($message)
|
||||
* @method bool hasCriticalThatMatches($message)
|
||||
* @method bool hasErrorThatMatches($message)
|
||||
* @method bool hasWarningThatMatches($message)
|
||||
* @method bool hasNoticeThatMatches($message)
|
||||
* @method bool hasInfoThatMatches($message)
|
||||
* @method bool hasDebugThatMatches($message)
|
||||
*
|
||||
* @method bool hasEmergencyThatPasses($message)
|
||||
* @method bool hasAlertThatPasses($message)
|
||||
* @method bool hasCriticalThatPasses($message)
|
||||
* @method bool hasErrorThatPasses($message)
|
||||
* @method bool hasWarningThatPasses($message)
|
||||
* @method bool hasNoticeThatPasses($message)
|
||||
* @method bool hasInfoThatPasses($message)
|
||||
* @method bool hasDebugThatPasses($message)
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
* @phpstan-import-type Level from \Monolog\Logger
|
||||
* @phpstan-import-type LevelName from \Monolog\Logger
|
||||
*/
|
||||
class TestHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/** @var Record[] */
|
||||
protected $records = [];
|
||||
/** @var array<Level, Record[]> */
|
||||
protected $recordsByLevel = [];
|
||||
/** @var bool */
|
||||
private $skipReset = \false;
|
||||
/**
|
||||
* @return array
|
||||
*
|
||||
* @phpstan-return Record[]
|
||||
*/
|
||||
public function getRecords()
|
||||
{
|
||||
return $this->records;
|
||||
}
|
||||
/**
|
||||
* @return void
|
||||
*/
|
||||
public function clear()
|
||||
{
|
||||
$this->records = [];
|
||||
$this->recordsByLevel = [];
|
||||
}
|
||||
/**
|
||||
* @return void
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
if (!$this->skipReset) {
|
||||
$this->clear();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @return void
|
||||
*/
|
||||
public function setSkipReset(bool $skipReset)
|
||||
{
|
||||
$this->skipReset = $skipReset;
|
||||
}
|
||||
/**
|
||||
* @param string|int $level Logging level value or name
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function hasRecords($level) : bool
|
||||
{
|
||||
return isset($this->recordsByLevel[Logger::toMonologLevel($level)]);
|
||||
}
|
||||
/**
|
||||
* @param string|array $record Either a message string or an array containing message and optionally context keys that will be checked against all records
|
||||
* @param string|int $level Logging level value or name
|
||||
*
|
||||
* @phpstan-param array{message: string, context?: mixed[]}|string $record
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function hasRecord($record, $level) : bool
|
||||
{
|
||||
if (\is_string($record)) {
|
||||
$record = array('message' => $record);
|
||||
}
|
||||
return $this->hasRecordThatPasses(function ($rec) use($record) {
|
||||
if ($rec['message'] !== $record['message']) {
|
||||
return \false;
|
||||
}
|
||||
if (isset($record['context']) && $rec['context'] !== $record['context']) {
|
||||
return \false;
|
||||
}
|
||||
return \true;
|
||||
}, $level);
|
||||
}
|
||||
/**
|
||||
* @param string|int $level Logging level value or name
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function hasRecordThatContains(string $message, $level) : bool
|
||||
{
|
||||
return $this->hasRecordThatPasses(function ($rec) use($message) {
|
||||
return \strpos($rec['message'], $message) !== \false;
|
||||
}, $level);
|
||||
}
|
||||
/**
|
||||
* @param string|int $level Logging level value or name
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function hasRecordThatMatches(string $regex, $level) : bool
|
||||
{
|
||||
return $this->hasRecordThatPasses(function (array $rec) use($regex) : bool {
|
||||
return \preg_match($regex, $rec['message']) > 0;
|
||||
}, $level);
|
||||
}
|
||||
/**
|
||||
* @param string|int $level Logging level value or name
|
||||
* @return bool
|
||||
*
|
||||
* @psalm-param callable(Record, int): mixed $predicate
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function hasRecordThatPasses(callable $predicate, $level)
|
||||
{
|
||||
$level = Logger::toMonologLevel($level);
|
||||
if (!isset($this->recordsByLevel[$level])) {
|
||||
return \false;
|
||||
}
|
||||
foreach ($this->recordsByLevel[$level] as $i => $rec) {
|
||||
if ($predicate($rec, $i)) {
|
||||
return \true;
|
||||
}
|
||||
}
|
||||
return \false;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->recordsByLevel[$record['level']][] = $record;
|
||||
$this->records[] = $record;
|
||||
}
|
||||
/**
|
||||
* @param string $method
|
||||
* @param mixed[] $args
|
||||
* @return bool
|
||||
*/
|
||||
public function __call($method, $args)
|
||||
{
|
||||
if (\preg_match('/(.*)(Debug|Info|Notice|Warning|Error|Critical|Alert|Emergency)(.*)/', $method, $matches) > 0) {
|
||||
$genericMethod = $matches[1] . ('Records' !== $matches[3] ? 'Record' : '') . $matches[3];
|
||||
$level = \constant('DeliciousBrains\\WP_Offload_Media\\Gcp\\Monolog\\Logger::' . \strtoupper($matches[2]));
|
||||
$callback = [$this, $genericMethod];
|
||||
if (\is_callable($callback)) {
|
||||
$args[] = $level;
|
||||
return \call_user_func_array($callback, $args);
|
||||
}
|
||||
}
|
||||
throw new \BadMethodCallException('Call to undefined method ' . \get_class($this) . '::' . $method . '()');
|
||||
}
|
||||
}
|
||||
24
vendor/Gcp/monolog/monolog/src/Monolog/Handler/WebRequestRecognizerTrait.php
vendored
Normal file
24
vendor/Gcp/monolog/monolog/src/Monolog/Handler/WebRequestRecognizerTrait.php
vendored
Normal file
@@ -0,0 +1,24 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
trait WebRequestRecognizerTrait
|
||||
{
|
||||
/**
|
||||
* Checks if PHP's serving a web request
|
||||
* @return bool
|
||||
*/
|
||||
protected function isWebRequest() : bool
|
||||
{
|
||||
return 'cli' !== \PHP_SAPI && 'phpdbg' !== \PHP_SAPI;
|
||||
}
|
||||
}
|
||||
76
vendor/Gcp/monolog/monolog/src/Monolog/Handler/WhatFailureGroupHandler.php
vendored
Normal file
76
vendor/Gcp/monolog/monolog/src/Monolog/Handler/WhatFailureGroupHandler.php
vendored
Normal file
@@ -0,0 +1,76 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
/**
|
||||
* Forwards records to multiple handlers suppressing failures of each handler
|
||||
* and continuing through to give every handler a chance to succeed.
|
||||
*
|
||||
* @author Craig D'Amelio <craig@damelio.ca>
|
||||
*
|
||||
* @phpstan-import-type Record from \Monolog\Logger
|
||||
*/
|
||||
class WhatFailureGroupHandler extends GroupHandler
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handle(array $record) : bool
|
||||
{
|
||||
if ($this->processors) {
|
||||
/** @var Record $record */
|
||||
$record = $this->processRecord($record);
|
||||
}
|
||||
foreach ($this->handlers as $handler) {
|
||||
try {
|
||||
$handler->handle($record);
|
||||
} catch (\Throwable $e) {
|
||||
// What failure?
|
||||
}
|
||||
}
|
||||
return \false === $this->bubble;
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function handleBatch(array $records) : void
|
||||
{
|
||||
if ($this->processors) {
|
||||
$processed = array();
|
||||
foreach ($records as $record) {
|
||||
$processed[] = $this->processRecord($record);
|
||||
}
|
||||
/** @var Record[] $records */
|
||||
$records = $processed;
|
||||
}
|
||||
foreach ($this->handlers as $handler) {
|
||||
try {
|
||||
$handler->handleBatch($records);
|
||||
} catch (\Throwable $e) {
|
||||
// What failure?
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
foreach ($this->handlers as $handler) {
|
||||
try {
|
||||
$handler->close();
|
||||
} catch (\Throwable $e) {
|
||||
// What failure?
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
79
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ZendMonitorHandler.php
vendored
Normal file
79
vendor/Gcp/monolog/monolog/src/Monolog/Handler/ZendMonitorHandler.php
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler;
|
||||
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\FormatterInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Formatter\NormalizerFormatter;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Logger;
|
||||
/**
|
||||
* Handler sending logs to Zend Monitor
|
||||
*
|
||||
* @author Christian Bergau <cbergau86@gmail.com>
|
||||
* @author Jason Davis <happydude@jasondavis.net>
|
||||
*
|
||||
* @phpstan-import-type FormattedRecord from AbstractProcessingHandler
|
||||
*/
|
||||
class ZendMonitorHandler extends AbstractProcessingHandler
|
||||
{
|
||||
/**
|
||||
* Monolog level / ZendMonitor Custom Event priority map
|
||||
*
|
||||
* @var array<int, int>
|
||||
*/
|
||||
protected $levelMap = [];
|
||||
/**
|
||||
* @throws MissingExtensionException
|
||||
*/
|
||||
public function __construct($level = Logger::DEBUG, bool $bubble = \true)
|
||||
{
|
||||
if (!\function_exists('DeliciousBrains\\WP_Offload_Media\\Gcp\\zend_monitor_custom_event')) {
|
||||
throw new MissingExtensionException('You must have Zend Server installed with Zend Monitor enabled in order to use this handler');
|
||||
}
|
||||
//zend monitor constants are not defined if zend monitor is not enabled.
|
||||
$this->levelMap = [Logger::DEBUG => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_INFO, Logger::INFO => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_INFO, Logger::NOTICE => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_INFO, Logger::WARNING => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_WARNING, Logger::ERROR => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_ERROR, Logger::CRITICAL => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_ERROR, Logger::ALERT => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_ERROR, Logger::EMERGENCY => \DeliciousBrains\WP_Offload_Media\Gcp\ZEND_MONITOR_EVENT_SEVERITY_ERROR];
|
||||
parent::__construct($level, $bubble);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function write(array $record) : void
|
||||
{
|
||||
$this->writeZendMonitorCustomEvent(Logger::getLevelName($record['level']), $record['message'], $record['formatted'], $this->levelMap[$record['level']]);
|
||||
}
|
||||
/**
|
||||
* Write to Zend Monitor Events
|
||||
* @param string $type Text displayed in "Class Name (custom)" field
|
||||
* @param string $message Text displayed in "Error String"
|
||||
* @param array $formatted Displayed in Custom Variables tab
|
||||
* @param int $severity Set the event severity level (-1,0,1)
|
||||
*
|
||||
* @phpstan-param FormattedRecord $formatted
|
||||
*/
|
||||
protected function writeZendMonitorCustomEvent(string $type, string $message, array $formatted, int $severity) : void
|
||||
{
|
||||
zend_monitor_custom_event($type, $message, $formatted, $severity);
|
||||
}
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getDefaultFormatter() : FormatterInterface
|
||||
{
|
||||
return new NormalizerFormatter();
|
||||
}
|
||||
/**
|
||||
* @return array<int, int>
|
||||
*/
|
||||
public function getLevelMap() : array
|
||||
{
|
||||
return $this->levelMap;
|
||||
}
|
||||
}
|
||||
33
vendor/Gcp/monolog/monolog/src/Monolog/LogRecord.php
vendored
Normal file
33
vendor/Gcp/monolog/monolog/src/Monolog/LogRecord.php
vendored
Normal file
@@ -0,0 +1,33 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog;
|
||||
|
||||
use ArrayAccess;
|
||||
/**
|
||||
* Monolog log record interface for forward compatibility with Monolog 3.0
|
||||
*
|
||||
* This is just present in Monolog 2.4+ to allow interoperable code to be written against
|
||||
* both versions by type-hinting arguments as `array|\Monolog\LogRecord $record`
|
||||
*
|
||||
* Do not rely on this interface for other purposes, and do not implement it.
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
* @template-extends \ArrayAccess<'message'|'level'|'context'|'level_name'|'channel'|'datetime'|'extra'|'formatted', mixed>
|
||||
* @phpstan-import-type Record from Logger
|
||||
*/
|
||||
interface LogRecord extends \ArrayAccess
|
||||
{
|
||||
/**
|
||||
* @phpstan-return Record
|
||||
*/
|
||||
public function toArray() : array;
|
||||
}
|
||||
636
vendor/Gcp/monolog/monolog/src/Monolog/Logger.php
vendored
Normal file
636
vendor/Gcp/monolog/monolog/src/Monolog/Logger.php
vendored
Normal file
@@ -0,0 +1,636 @@
|
||||
<?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 DeliciousBrains\WP_Offload_Media\Gcp\Monolog;
|
||||
|
||||
use DateTimeZone;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Monolog\Handler\HandlerInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LoggerInterface;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\InvalidArgumentException;
|
||||
use DeliciousBrains\WP_Offload_Media\Gcp\Psr\Log\LogLevel;
|
||||
use Throwable;
|
||||
use Stringable;
|
||||
/**
|
||||
* Monolog log channel
|
||||
*
|
||||
* It contains a stack of Handlers and a stack of Processors,
|
||||
* and uses them to store records that are added to it.
|
||||
*
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* @phpstan-type Level Logger::DEBUG|Logger::INFO|Logger::NOTICE|Logger::WARNING|Logger::ERROR|Logger::CRITICAL|Logger::ALERT|Logger::EMERGENCY
|
||||
* @phpstan-type LevelName 'DEBUG'|'INFO'|'NOTICE'|'WARNING'|'ERROR'|'CRITICAL'|'ALERT'|'EMERGENCY'
|
||||
* @phpstan-type Record array{message: string, context: mixed[], level: Level, level_name: LevelName, channel: string, datetime: \DateTimeImmutable, extra: mixed[]}
|
||||
*/
|
||||
class Logger implements LoggerInterface, ResettableInterface
|
||||
{
|
||||
/**
|
||||
* Detailed debug information
|
||||
*/
|
||||
public const DEBUG = 100;
|
||||
/**
|
||||
* Interesting events
|
||||
*
|
||||
* Examples: User logs in, SQL logs.
|
||||
*/
|
||||
public const INFO = 200;
|
||||
/**
|
||||
* Uncommon events
|
||||
*/
|
||||
public const NOTICE = 250;
|
||||
/**
|
||||
* Exceptional occurrences that are not errors
|
||||
*
|
||||
* Examples: Use of deprecated APIs, poor use of an API,
|
||||
* undesirable things that are not necessarily wrong.
|
||||
*/
|
||||
public const WARNING = 300;
|
||||
/**
|
||||
* Runtime errors
|
||||
*/
|
||||
public const ERROR = 400;
|
||||
/**
|
||||
* Critical conditions
|
||||
*
|
||||
* Example: Application component unavailable, unexpected exception.
|
||||
*/
|
||||
public const CRITICAL = 500;
|
||||
/**
|
||||
* Action must be taken immediately
|
||||
*
|
||||
* Example: Entire website down, database unavailable, etc.
|
||||
* This should trigger the SMS alerts and wake you up.
|
||||
*/
|
||||
public const ALERT = 550;
|
||||
/**
|
||||
* Urgent alert.
|
||||
*/
|
||||
public const EMERGENCY = 600;
|
||||
/**
|
||||
* Monolog API version
|
||||
*
|
||||
* This is only bumped when API breaks are done and should
|
||||
* follow the major version of the library
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public const API = 2;
|
||||
/**
|
||||
* This is a static variable and not a constant to serve as an extension point for custom levels
|
||||
*
|
||||
* @var array<int, string> $levels Logging levels with the levels as key
|
||||
*
|
||||
* @phpstan-var array<Level, LevelName> $levels Logging levels with the levels as key
|
||||
*/
|
||||
protected static $levels = [self::DEBUG => 'DEBUG', self::INFO => 'INFO', self::NOTICE => 'NOTICE', self::WARNING => 'WARNING', self::ERROR => 'ERROR', self::CRITICAL => 'CRITICAL', self::ALERT => 'ALERT', self::EMERGENCY => 'EMERGENCY'];
|
||||
/**
|
||||
* Mapping between levels numbers defined in RFC 5424 and Monolog ones
|
||||
*
|
||||
* @phpstan-var array<int, Level> $rfc_5424_levels
|
||||
*/
|
||||
private const RFC_5424_LEVELS = [7 => self::DEBUG, 6 => self::INFO, 5 => self::NOTICE, 4 => self::WARNING, 3 => self::ERROR, 2 => self::CRITICAL, 1 => self::ALERT, 0 => self::EMERGENCY];
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $name;
|
||||
/**
|
||||
* The handler stack
|
||||
*
|
||||
* @var HandlerInterface[]
|
||||
*/
|
||||
protected $handlers;
|
||||
/**
|
||||
* Processors that will process all log records
|
||||
*
|
||||
* To process records of a single handler instead, add the processor on that specific handler
|
||||
*
|
||||
* @var callable[]
|
||||
*/
|
||||
protected $processors;
|
||||
/**
|
||||
* @var bool
|
||||
*/
|
||||
protected $microsecondTimestamps = \true;
|
||||
/**
|
||||
* @var DateTimeZone
|
||||
*/
|
||||
protected $timezone;
|
||||
/**
|
||||
* @var callable|null
|
||||
*/
|
||||
protected $exceptionHandler;
|
||||
/**
|
||||
* @var int Keeps track of depth to prevent infinite logging loops
|
||||
*/
|
||||
private $logDepth = 0;
|
||||
/**
|
||||
* @var \WeakMap<\Fiber<mixed, mixed, mixed, mixed>, int> Keeps track of depth inside fibers to prevent infinite logging loops
|
||||
*/
|
||||
private $fiberLogDepth;
|
||||
/**
|
||||
* @var bool Whether to detect infinite logging loops
|
||||
*
|
||||
* This can be disabled via {@see useLoggingLoopDetection} if you have async handlers that do not play well with this
|
||||
*/
|
||||
private $detectCycles = \true;
|
||||
/**
|
||||
* @psalm-param array<callable(array): array> $processors
|
||||
*
|
||||
* @param string $name The logging channel, a simple descriptive name that is attached to all log records
|
||||
* @param HandlerInterface[] $handlers Optional stack of handlers, the first one in the array is called first, etc.
|
||||
* @param callable[] $processors Optional array of processors
|
||||
* @param DateTimeZone|null $timezone Optional timezone, if not provided date_default_timezone_get() will be used
|
||||
*/
|
||||
public function __construct(string $name, array $handlers = [], array $processors = [], ?DateTimeZone $timezone = null)
|
||||
{
|
||||
$this->name = $name;
|
||||
$this->setHandlers($handlers);
|
||||
$this->processors = $processors;
|
||||
$this->timezone = $timezone ?: new DateTimeZone(\date_default_timezone_get() ?: 'UTC');
|
||||
if (\PHP_VERSION_ID >= 80100) {
|
||||
// Local variable for phpstan, see https://github.com/phpstan/phpstan/issues/6732#issuecomment-1111118412
|
||||
/** @var \WeakMap<\Fiber<mixed, mixed, mixed, mixed>, int> $fiberLogDepth */
|
||||
$fiberLogDepth = new \WeakMap();
|
||||
$this->fiberLogDepth = $fiberLogDepth;
|
||||
}
|
||||
}
|
||||
public function getName() : string
|
||||
{
|
||||
return $this->name;
|
||||
}
|
||||
/**
|
||||
* Return a new cloned instance with the name changed
|
||||
*/
|
||||
public function withName(string $name) : self
|
||||
{
|
||||
$new = clone $this;
|
||||
$new->name = $name;
|
||||
return $new;
|
||||
}
|
||||
/**
|
||||
* Pushes a handler on to the stack.
|
||||
*/
|
||||
public function pushHandler(HandlerInterface $handler) : self
|
||||
{
|
||||
\array_unshift($this->handlers, $handler);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Pops a handler from the stack
|
||||
*
|
||||
* @throws \LogicException If empty handler stack
|
||||
*/
|
||||
public function popHandler() : HandlerInterface
|
||||
{
|
||||
if (!$this->handlers) {
|
||||
throw new \LogicException('You tried to pop from an empty handler stack.');
|
||||
}
|
||||
return \array_shift($this->handlers);
|
||||
}
|
||||
/**
|
||||
* Set handlers, replacing all existing ones.
|
||||
*
|
||||
* If a map is passed, keys will be ignored.
|
||||
*
|
||||
* @param HandlerInterface[] $handlers
|
||||
*/
|
||||
public function setHandlers(array $handlers) : self
|
||||
{
|
||||
$this->handlers = [];
|
||||
foreach (\array_reverse($handlers) as $handler) {
|
||||
$this->pushHandler($handler);
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* @return HandlerInterface[]
|
||||
*/
|
||||
public function getHandlers() : array
|
||||
{
|
||||
return $this->handlers;
|
||||
}
|
||||
/**
|
||||
* Adds a processor on to the stack.
|
||||
*/
|
||||
public function pushProcessor(callable $callback) : self
|
||||
{
|
||||
\array_unshift($this->processors, $callback);
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Removes the processor on top of the stack and returns it.
|
||||
*
|
||||
* @throws \LogicException If empty processor stack
|
||||
* @return callable
|
||||
*/
|
||||
public function popProcessor() : callable
|
||||
{
|
||||
if (!$this->processors) {
|
||||
throw new \LogicException('You tried to pop from an empty processor stack.');
|
||||
}
|
||||
return \array_shift($this->processors);
|
||||
}
|
||||
/**
|
||||
* @return callable[]
|
||||
*/
|
||||
public function getProcessors() : array
|
||||
{
|
||||
return $this->processors;
|
||||
}
|
||||
/**
|
||||
* Control the use of microsecond resolution timestamps in the 'datetime'
|
||||
* member of new records.
|
||||
*
|
||||
* As of PHP7.1 microseconds are always included by the engine, so
|
||||
* there is no performance penalty and Monolog 2 enabled microseconds
|
||||
* by default. This function lets you disable them though in case you want
|
||||
* to suppress microseconds from the output.
|
||||
*
|
||||
* @param bool $micro True to use microtime() to create timestamps
|
||||
*/
|
||||
public function useMicrosecondTimestamps(bool $micro) : self
|
||||
{
|
||||
$this->microsecondTimestamps = $micro;
|
||||
return $this;
|
||||
}
|
||||
public function useLoggingLoopDetection(bool $detectCycles) : self
|
||||
{
|
||||
$this->detectCycles = $detectCycles;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Adds a log record.
|
||||
*
|
||||
* @param int $level The logging level (a Monolog or RFC 5424 level)
|
||||
* @param string $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
* @param DateTimeImmutable $datetime Optional log date to log into the past or future
|
||||
* @return bool Whether the record has been processed
|
||||
*
|
||||
* @phpstan-param Level $level
|
||||
*/
|
||||
public function addRecord(int $level, string $message, array $context = [], ?DateTimeImmutable $datetime = null) : bool
|
||||
{
|
||||
if (isset(self::RFC_5424_LEVELS[$level])) {
|
||||
$level = self::RFC_5424_LEVELS[$level];
|
||||
}
|
||||
if ($this->detectCycles) {
|
||||
if (\PHP_VERSION_ID >= 80100 && ($fiber = \Fiber::getCurrent())) {
|
||||
// @phpstan-ignore offsetAssign.dimType
|
||||
$this->fiberLogDepth[$fiber] = $this->fiberLogDepth[$fiber] ?? 0;
|
||||
$logDepth = ++$this->fiberLogDepth[$fiber];
|
||||
} else {
|
||||
$logDepth = ++$this->logDepth;
|
||||
}
|
||||
} else {
|
||||
$logDepth = 0;
|
||||
}
|
||||
if ($logDepth === 3) {
|
||||
$this->warning('A possible infinite logging loop was detected and aborted. It appears some of your handler code is triggering logging, see the previous log record for a hint as to what may be the cause.');
|
||||
return \false;
|
||||
} elseif ($logDepth >= 5) {
|
||||
// log depth 4 is let through, so we can log the warning above
|
||||
return \false;
|
||||
}
|
||||
try {
|
||||
$record = null;
|
||||
foreach ($this->handlers as $handler) {
|
||||
if (null === $record) {
|
||||
// skip creating the record as long as no handler is going to handle it
|
||||
if (!$handler->isHandling(['level' => $level])) {
|
||||
continue;
|
||||
}
|
||||
$levelName = static::getLevelName($level);
|
||||
$record = ['message' => $message, 'context' => $context, 'level' => $level, 'level_name' => $levelName, 'channel' => $this->name, 'datetime' => $datetime ?? new DateTimeImmutable($this->microsecondTimestamps, $this->timezone), 'extra' => []];
|
||||
try {
|
||||
foreach ($this->processors as $processor) {
|
||||
$record = $processor($record);
|
||||
}
|
||||
} catch (Throwable $e) {
|
||||
$this->handleException($e, $record);
|
||||
return \true;
|
||||
}
|
||||
}
|
||||
// once the record exists, send it to all handlers as long as the bubbling chain is not interrupted
|
||||
try {
|
||||
if (\true === $handler->handle($record)) {
|
||||
break;
|
||||
}
|
||||
} catch (Throwable $e) {
|
||||
$this->handleException($e, $record);
|
||||
return \true;
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
if ($this->detectCycles) {
|
||||
if (isset($fiber)) {
|
||||
$this->fiberLogDepth[$fiber]--;
|
||||
} else {
|
||||
$this->logDepth--;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null !== $record;
|
||||
}
|
||||
/**
|
||||
* Ends a log cycle and frees all resources used by handlers.
|
||||
*
|
||||
* Closing a Handler means flushing all buffers and freeing any open resources/handles.
|
||||
* Handlers that have been closed should be able to accept log records again and re-open
|
||||
* themselves on demand, but this may not always be possible depending on implementation.
|
||||
*
|
||||
* This is useful at the end of a request and will be called automatically on every handler
|
||||
* when they get destructed.
|
||||
*/
|
||||
public function close() : void
|
||||
{
|
||||
foreach ($this->handlers as $handler) {
|
||||
$handler->close();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Ends a log cycle and resets all handlers and processors to their initial state.
|
||||
*
|
||||
* Resetting a Handler or a Processor means flushing/cleaning all buffers, resetting internal
|
||||
* state, and getting it back to a state in which it can receive log records again.
|
||||
*
|
||||
* This is useful in case you want to avoid logs leaking between two requests or jobs when you
|
||||
* have a long running process like a worker or an application server serving multiple requests
|
||||
* in one process.
|
||||
*/
|
||||
public function reset() : void
|
||||
{
|
||||
foreach ($this->handlers as $handler) {
|
||||
if ($handler instanceof ResettableInterface) {
|
||||
$handler->reset();
|
||||
}
|
||||
}
|
||||
foreach ($this->processors as $processor) {
|
||||
if ($processor instanceof ResettableInterface) {
|
||||
$processor->reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Gets all supported logging levels.
|
||||
*
|
||||
* @return array<string, int> Assoc array with human-readable level names => level codes.
|
||||
* @phpstan-return array<LevelName, Level>
|
||||
*/
|
||||
public static function getLevels() : array
|
||||
{
|
||||
return \array_flip(static::$levels);
|
||||
}
|
||||
/**
|
||||
* Gets the name of the logging level.
|
||||
*
|
||||
* @throws \Psr\Log\InvalidArgumentException If level is not defined
|
||||
*
|
||||
* @phpstan-param Level $level
|
||||
* @phpstan-return LevelName
|
||||
*/
|
||||
public static function getLevelName(int $level) : string
|
||||
{
|
||||
if (!isset(static::$levels[$level])) {
|
||||
throw new InvalidArgumentException('Level "' . $level . '" is not defined, use one of: ' . \implode(', ', \array_keys(static::$levels)));
|
||||
}
|
||||
return static::$levels[$level];
|
||||
}
|
||||
/**
|
||||
* Converts PSR-3 levels to Monolog ones if necessary
|
||||
*
|
||||
* @param string|int $level Level number (monolog) or name (PSR-3)
|
||||
* @throws \Psr\Log\InvalidArgumentException If level is not defined
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
* @phpstan-return Level
|
||||
*/
|
||||
public static function toMonologLevel($level) : int
|
||||
{
|
||||
if (\is_string($level)) {
|
||||
if (\is_numeric($level)) {
|
||||
/** @phpstan-ignore-next-line */
|
||||
return \intval($level);
|
||||
}
|
||||
// Contains chars of all log levels and avoids using strtoupper() which may have
|
||||
// strange results depending on locale (for example, "i" will become "İ" in Turkish locale)
|
||||
$upper = \strtr($level, 'abcdefgilmnortuwy', 'ABCDEFGILMNORTUWY');
|
||||
if (\defined(__CLASS__ . '::' . $upper)) {
|
||||
return \constant(__CLASS__ . '::' . $upper);
|
||||
}
|
||||
throw new InvalidArgumentException('Level "' . $level . '" is not defined, use one of: ' . \implode(', ', \array_keys(static::$levels) + static::$levels));
|
||||
}
|
||||
if (!\is_int($level)) {
|
||||
throw new InvalidArgumentException('Level "' . \var_export($level, \true) . '" is not defined, use one of: ' . \implode(', ', \array_keys(static::$levels) + static::$levels));
|
||||
}
|
||||
return $level;
|
||||
}
|
||||
/**
|
||||
* Checks whether the Logger has a handler that listens on the given level
|
||||
*
|
||||
* @phpstan-param Level $level
|
||||
*/
|
||||
public function isHandling(int $level) : bool
|
||||
{
|
||||
$record = ['level' => $level];
|
||||
foreach ($this->handlers as $handler) {
|
||||
if ($handler->isHandling($record)) {
|
||||
return \true;
|
||||
}
|
||||
}
|
||||
return \false;
|
||||
}
|
||||
/**
|
||||
* Set a custom exception handler that will be called if adding a new record fails
|
||||
*
|
||||
* The callable will receive an exception object and the record that failed to be logged
|
||||
*/
|
||||
public function setExceptionHandler(?callable $callback) : self
|
||||
{
|
||||
$this->exceptionHandler = $callback;
|
||||
return $this;
|
||||
}
|
||||
public function getExceptionHandler() : ?callable
|
||||
{
|
||||
return $this->exceptionHandler;
|
||||
}
|
||||
/**
|
||||
* Adds a log record at an arbitrary level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param mixed $level The log level (a Monolog, PSR-3 or RFC 5424 level)
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*
|
||||
* @phpstan-param Level|LevelName|LogLevel::* $level
|
||||
*/
|
||||
public function log($level, $message, array $context = []) : void
|
||||
{
|
||||
if (!\is_int($level) && !\is_string($level)) {
|
||||
throw new \InvalidArgumentException('$level is expected to be a string or int');
|
||||
}
|
||||
if (isset(self::RFC_5424_LEVELS[$level])) {
|
||||
$level = self::RFC_5424_LEVELS[$level];
|
||||
}
|
||||
$level = static::toMonologLevel($level);
|
||||
$this->addRecord($level, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the DEBUG level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function debug($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::DEBUG, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the INFO level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function info($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::INFO, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the NOTICE level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function notice($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::NOTICE, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the WARNING level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function warning($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::WARNING, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the ERROR level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function error($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::ERROR, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the CRITICAL level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function critical($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::CRITICAL, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the ALERT level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function alert($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::ALERT, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Adds a log record at the EMERGENCY level.
|
||||
*
|
||||
* This method allows for compatibility with common interfaces.
|
||||
*
|
||||
* @param string|Stringable $message The log message
|
||||
* @param mixed[] $context The log context
|
||||
*/
|
||||
public function emergency($message, array $context = []) : void
|
||||
{
|
||||
$this->addRecord(static::EMERGENCY, (string) $message, $context);
|
||||
}
|
||||
/**
|
||||
* Sets the timezone to be used for the timestamp of log records.
|
||||
*/
|
||||
public function setTimezone(DateTimeZone $tz) : self
|
||||
{
|
||||
$this->timezone = $tz;
|
||||
return $this;
|
||||
}
|
||||
/**
|
||||
* Returns the timezone to be used for the timestamp of log records.
|
||||
*/
|
||||
public function getTimezone() : DateTimeZone
|
||||
{
|
||||
return $this->timezone;
|
||||
}
|
||||
/**
|
||||
* Delegates exception management to the custom exception handler,
|
||||
* or throws the exception if no custom handler is set.
|
||||
*
|
||||
* @param array $record
|
||||
* @phpstan-param Record $record
|
||||
*/
|
||||
protected function handleException(Throwable $e, array $record) : void
|
||||
{
|
||||
if (!$this->exceptionHandler) {
|
||||
throw $e;
|
||||
}
|
||||
($this->exceptionHandler)($e, $record);
|
||||
}
|
||||
/**
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
public function __serialize() : array
|
||||
{
|
||||
return ['name' => $this->name, 'handlers' => $this->handlers, 'processors' => $this->processors, 'microsecondTimestamps' => $this->microsecondTimestamps, 'timezone' => $this->timezone, 'exceptionHandler' => $this->exceptionHandler, 'logDepth' => $this->logDepth, 'detectCycles' => $this->detectCycles];
|
||||
}
|
||||
/**
|
||||
* @param array<string, mixed> $data
|
||||
*/
|
||||
public function __unserialize(array $data) : void
|
||||
{
|
||||
foreach (['name', 'handlers', 'processors', 'microsecondTimestamps', 'timezone', 'exceptionHandler', 'logDepth', 'detectCycles'] as $property) {
|
||||
if (isset($data[$property])) {
|
||||
$this->{$property} = $data[$property];
|
||||
}
|
||||
}
|
||||
if (\PHP_VERSION_ID >= 80100) {
|
||||
// Local variable for phpstan, see https://github.com/phpstan/phpstan/issues/6732#issuecomment-1111118412
|
||||
/** @var \WeakMap<\Fiber<mixed, mixed, mixed, mixed>, int> $fiberLogDepth */
|
||||
$fiberLogDepth = new \WeakMap();
|
||||
$this->fiberLogDepth = $fiberLogDepth;
|
||||
}
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user