+ */
+ 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 = ''.htmlspecialchars($td, ENT_NOQUOTES, 'UTF-8').'
';
+ }
+
+ return "\n| $th: | \n".$td." | \n
";
+ }
+
+ /**
+ * 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 ''.$title.'
';
+ }
+
+ /**
+ * Formats a log record.
+ *
+ * @return string The formatted record
+ */
+ public function format(array $record): string
+ {
+ $output = $this->addTitle($record['level_name'], $record['level']);
+ $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 = '';
+ foreach ($record['context'] as $key => $value) {
+ $embeddedTable .= $this->addRow((string) $key, $this->convertToString($value));
+ }
+ $embeddedTable .= '
';
+ $output .= $this->addRow('Context', $embeddedTable, false);
+ }
+ if ($record['extra']) {
+ $embeddedTable = '';
+ foreach ($record['extra'] as $key => $value) {
+ $embeddedTable .= $this->addRow((string) $key, $this->convertToString($value));
+ }
+ $embeddedTable .= '
';
+ $output .= $this->addRow('Extra', $embeddedTable, false);
+ }
+
+ return $output.'
';
+ }
+
+ /**
+ * 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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/JsonFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/JsonFormatter.php
new file mode 100755
index 0000000..b737d82
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/JsonFormatter.php
@@ -0,0 +1,224 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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
+ *
+ * @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 (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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LineFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LineFormatter.php
new file mode 100755
index 0000000..e6e7898
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LineFormatter.php
@@ -0,0 +1,246 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+use Monolog\Utils;
+
+/**
+ * Formats incoming records into a one-line string
+ *
+ * This is especially useful for logging to files
+ *
+ * @author Jordi Boggiano
+ * @author Christophe Coevoet
+ */
+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('/(?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))));
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogglyFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogglyFormatter.php
new file mode 100755
index 0000000..29841aa
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogglyFormatter.php
@@ -0,0 +1,45 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+/**
+ * Encodes message information into JSON in a format compatible with Loggly.
+ *
+ * @author Adam Pancutt
+ */
+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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogmaticFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogmaticFormatter.php
new file mode 100755
index 0000000..b0451ab
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogmaticFormatter.php
@@ -0,0 +1,66 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+/**
+ * Encodes message information into JSON in a format compatible with Logmatic.
+ *
+ * @author Julien Breux
+ */
+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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogstashFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogstashFormatter.php
new file mode 100755
index 0000000..f8de0d3
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/LogstashFormatter.php
@@ -0,0 +1,101 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+/**
+ * Serializes a log message to Logstash Event Format
+ *
+ * @see https://www.elastic.co/products/logstash
+ * @see https://github.com/elastic/logstash/blob/master/logstash-core/src/main/java/org/logstash/Event.java
+ *
+ * @author Tim Mower
+ */
+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";
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/MongoDBFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/MongoDBFormatter.php
new file mode 100755
index 0000000..fca69a8
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/MongoDBFormatter.php
@@ -0,0 +1,162 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+use MongoDB\BSON\Type;
+use MongoDB\BSON\UTCDateTime;
+use Monolog\Utils;
+
+/**
+ * Formats a record for use with the MongoDBHandler.
+ *
+ * @author Florian Plattner
+ */
+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
+ */
+ 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) //64-bit OS?
+ ? (int) $milliseconds
+ : (string) $milliseconds;
+
+ // @phpstan-ignore-next-line
+ return new UTCDateTime($milliseconds);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/NormalizerFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/NormalizerFormatter.php
new file mode 100755
index 0000000..f926a84
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/NormalizerFormatter.php
@@ -0,0 +1,290 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+use Monolog\DateTimeImmutable;
+use Monolog\Utils;
+use Throwable;
+
+/**
+ * Normalizes incoming records to remove objects/resources so it's easier to dump to various targets
+ *
+ * @author Jordi Boggiano
+ */
+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
+ */
+ 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 $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 $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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/ScalarFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/ScalarFormatter.php
new file mode 100755
index 0000000..187bc55
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/ScalarFormatter.php
@@ -0,0 +1,51 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+/**
+ * Formats data into an associative array of scalar values.
+ * Objects and arrays will be JSON encoded.
+ *
+ * @author Andrew Lawson
+ */
+class ScalarFormatter extends NormalizerFormatter
+{
+ /**
+ * {@inheritDoc}
+ *
+ * @phpstan-return array $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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/WildfireFormatter.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/WildfireFormatter.php
new file mode 100755
index 0000000..6539b34
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Formatter/WildfireFormatter.php
@@ -0,0 +1,139 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Formatter;
+
+use Monolog\Logger;
+
+/**
+ * Serializes a log message according to Wildfire's header requirements
+ *
+ * @author Eric Clemmons (@ericclemmons)
+ * @author Christophe Coevoet
+ * @author Kirill chEbba Chebunin
+ *
+ * @phpstan-import-type Level from \Monolog\Logger
+ */
+class WildfireFormatter extends NormalizerFormatter
+{
+ /**
+ * Translates Monolog log levels to Wildfire levels.
+ *
+ * @var array
+ */
+ 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|object
+ */
+ protected function normalize($data, int $depth = 0)
+ {
+ if (is_object($data) && !$data instanceof \DateTimeInterface) {
+ return $data;
+ }
+
+ return parent::normalize($data, $depth);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractHandler.php
new file mode 100755
index 0000000..a5cdaa7
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractHandler.php
@@ -0,0 +1,112 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\ResettableInterface;
+use Psr\Log\LogLevel;
+
+/**
+ * Base Handler class providing basic level/bubble support
+ *
+ * @author Jordi Boggiano
+ *
+ * @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()
+ {
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractProcessingHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractProcessingHandler.php
new file mode 100755
index 0000000..77e533f
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractProcessingHandler.php
@@ -0,0 +1,69 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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
+ * @author Christophe Coevoet
+ *
+ * @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
+ */
+ abstract protected function write(array $record): void;
+
+ /**
+ * @return void
+ */
+ public function reset()
+ {
+ parent::reset();
+
+ $this->resetProcessors();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractSyslogHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractSyslogHandler.php
new file mode 100755
index 0000000..5e5ad1c
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AbstractSyslogHandler.php
@@ -0,0 +1,106 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Formatter\FormatterInterface;
+use 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
+ */
+ 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
+ */
+ 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%');
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AmqpHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AmqpHandler.php
new file mode 100755
index 0000000..994872c
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/AmqpHandler.php
@@ -0,0 +1,171 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\JsonFormatter;
+use PhpAmqpLib\Message\AMQPMessage;
+use PhpAmqpLib\Channel\AMQPChannel;
+use AMQPExchange;
+
+/**
+ * @phpstan-import-type Record from \Monolog\Logger
+ */
+class AmqpHandler extends AbstractProcessingHandler
+{
+ /**
+ * @var AMQPExchange|AMQPChannel $exchange
+ */
+ protected $exchange;
+ /** @var array */
+ private $extraAttributes = [];
+
+ /**
+ * @return array
+ */
+ public function getExtraAttributes(): array
+ {
+ return $this->extraAttributes;
+ }
+
+ /**
+ * Configure extra attributes to pass to the AMQPExchange (if you are using the amqp extension)
+ *
+ * @param array $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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/BrowserConsoleHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/BrowserConsoleHandler.php
new file mode 100755
index 0000000..95bbfed
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/BrowserConsoleHandler.php
@@ -0,0 +1,308 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LineFormatter;
+use Monolog\Utils;
+use 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
+ *
+ * @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('');
+ } 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(['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) . ');';
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/BufferHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/BufferHandler.php
new file mode 100755
index 0000000..fcce5d6
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/BufferHandler.php
@@ -0,0 +1,167 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\ResettableInterface;
+use 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
+ *
+ * @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.');
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ChromePHPHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ChromePHPHandler.php
new file mode 100755
index 0000000..234ecf6
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ChromePHPHandler.php
@@ -0,0 +1,196 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\ChromePHPFormatter;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Logger;
+use 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
+ *
+ * @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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/CouchDBHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/CouchDBHandler.php
new file mode 100755
index 0000000..5265761
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/CouchDBHandler.php
@@ -0,0 +1,77 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\JsonFormatter;
+use Monolog\Logger;
+
+/**
+ * CouchDB handler
+ *
+ * @author Markus Bachmann
+ */
+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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/CubeHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/CubeHandler.php
new file mode 100755
index 0000000..3535a4f
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/CubeHandler.php
@@ -0,0 +1,167 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Utils;
+
+/**
+ * Logs to Cube.
+ *
+ * @link https://github.com/square/cube/wiki
+ * @author Wan Chen
+ * @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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Curl/Util.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Curl/Util.php
new file mode 100755
index 0000000..7213e8e
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Curl/Util.php
@@ -0,0 +1,71 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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 */
+ 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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DeduplicationHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DeduplicationHandler.php
new file mode 100755
index 0000000..9b85ae7
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DeduplicationHandler.php
@@ -0,0 +1,186 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use 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
+ *
+ * @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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DoctrineCouchDBHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DoctrineCouchDBHandler.php
new file mode 100755
index 0000000..ebd52c3
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DoctrineCouchDBHandler.php
@@ -0,0 +1,47 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Formatter\NormalizerFormatter;
+use Monolog\Formatter\FormatterInterface;
+use Doctrine\CouchDB\CouchDBClient;
+
+/**
+ * CouchDB handler for Doctrine CouchDB ODM
+ *
+ * @author Markus Bachmann
+ */
+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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DynamoDbHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DynamoDbHandler.php
new file mode 100755
index 0000000..21840bf
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/DynamoDbHandler.php
@@ -0,0 +1,104 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Aws\Sdk;
+use Aws\DynamoDb\DynamoDbClient;
+use Monolog\Formatter\FormatterInterface;
+use Aws\DynamoDb\Marshaler;
+use Monolog\Formatter\ScalarFormatter;
+use Monolog\Logger;
+
+/**
+ * Amazon DynamoDB handler (http://aws.amazon.com/dynamodb/)
+ *
+ * @link https://github.com/aws/aws-sdk-php/
+ * @author Andrew Lawson
+ */
+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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ElasticaHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ElasticaHandler.php
new file mode 100755
index 0000000..fc92ca4
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ElasticaHandler.php
@@ -0,0 +1,129 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Elastica\Document;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\ElasticaFormatter;
+use Monolog\Logger;
+use Elastica\Client;
+use Elastica\Exception\ExceptionInterface;
+
+/**
+ * Elastic Search handler
+ *
+ * Usage example:
+ *
+ * $client = new \Elastica\Client();
+ * $options = array(
+ * 'index' => 'elastic_index_name',
+ * 'type' => 'elastic_doc_type', Types have been removed in Elastica 7
+ * );
+ * $handler = new ElasticaHandler($client, $options);
+ * $log = new Logger('application');
+ * $log->pushHandler($handler);
+ *
+ * @author Jelle Vink
+ */
+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, // Suppress Elastica exceptions
+ ],
+ $options
+ );
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ protected function write(array $record): void
+ {
+ $this->bulkSend([$record['formatted']]);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function setFormatter(FormatterInterface $formatter): HandlerInterface
+ {
+ if ($formatter instanceof ElasticaFormatter) {
+ return parent::setFormatter($formatter);
+ }
+
+ throw new \InvalidArgumentException('ElasticaHandler is only compatible with ElasticaFormatter');
+ }
+
+ /**
+ * @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);
+ }
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ElasticsearchHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ElasticsearchHandler.php
new file mode 100755
index 0000000..e88375c
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ElasticsearchHandler.php
@@ -0,0 +1,218 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Elastic\Elasticsearch\Response\Elasticsearch;
+use Throwable;
+use RuntimeException;
+use Monolog\Logger;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\ElasticsearchFormatter;
+use InvalidArgumentException;
+use Elasticsearch\Common\Exceptions\RuntimeException as ElasticsearchRuntimeException;
+use Elasticsearch\Client;
+use Elastic\Elasticsearch\Exception\InvalidArgumentException as ElasticInvalidArgumentException;
+use 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
+ */
+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, // Suppress Elasticsearch exceptions
+ ],
+ $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
+ {
+ 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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ErrorLogHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ErrorLogHandler.php
new file mode 100755
index 0000000..f2e2203
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ErrorLogHandler.php
@@ -0,0 +1,91 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\LineFormatter;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Logger;
+use Monolog\Utils;
+
+/**
+ * Stores to PHP error_log() handler.
+ *
+ * @author Elan Ruusamäe
+ */
+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);
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FallbackGroupHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FallbackGroupHandler.php
new file mode 100755
index 0000000..d4e234c
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FallbackGroupHandler.php
@@ -0,0 +1,71 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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?
+ }
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FilterHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FilterHandler.php
new file mode 100755
index 0000000..718f17e
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FilterHandler.php
@@ -0,0 +1,212 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\ResettableInterface;
+use Monolog\Formatter\FormatterInterface;
+use 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
+ *
+ * @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
+ */
+ 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 $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
+ */
+ 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 $minLevelOrList
+ * @phpstan-param Level|LevelName|LogLevel::* $maxLevel
+ */
+ public function setAcceptedLevels($minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY): self
+ {
+ if (is_array($minLevelOrList)) {
+ $acceptedLevels = array_map('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();
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.php
new file mode 100755
index 0000000..0aa5607
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ActivationStrategyInterface.php
@@ -0,0 +1,29 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler\FingersCrossed;
+
+/**
+ * Interface for activation strategies for the FingersCrossedHandler.
+ *
+ * @author Johannes M. Schmitt
+ *
+ * @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;
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.php
new file mode 100755
index 0000000..7b9abb5
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ChannelLevelActivationStrategy.php
@@ -0,0 +1,77 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler\FingersCrossed;
+
+use Monolog\Logger;
+use 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:
+ *
+ *
+ * $activationStrategy = new ChannelLevelActivationStrategy(
+ * Logger::CRITICAL,
+ * array(
+ * 'request' => Logger::ALERT,
+ * 'sensitive' => Logger::ERROR,
+ * )
+ * );
+ * $handler = new FingersCrossedHandler(new StreamHandler('php://stderr'), $activationStrategy);
+ *
+ *
+ * @author Mike Meessen
+ *
+ * @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
+ */
+ private $channelToActionLevel;
+
+ /**
+ * @param int|string $defaultActionLevel The default action level to be used if the record's category doesn't match any
+ * @param array $channelToActionLevel An array that maps channel names to action levels.
+ *
+ * @phpstan-param array $channelToActionLevel
+ * @phpstan-param Level|LevelName|LogLevel::* $defaultActionLevel
+ */
+ public function __construct($defaultActionLevel, array $channelToActionLevel = [])
+ {
+ $this->defaultActionLevel = Logger::toMonologLevel($defaultActionLevel);
+ $this->channelToActionLevel = array_map('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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.php
new file mode 100755
index 0000000..5ec88ea
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossed/ErrorLevelActivationStrategy.php
@@ -0,0 +1,46 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler\FingersCrossed;
+
+use Monolog\Logger;
+use Psr\Log\LogLevel;
+
+/**
+ * Error level based activation strategy.
+ *
+ * @author Johannes M. Schmitt
+ *
+ * @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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossedHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossedHandler.php
new file mode 100755
index 0000000..0627b44
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FingersCrossedHandler.php
@@ -0,0 +1,252 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Handler\FingersCrossed\ErrorLevelActivationStrategy;
+use Monolog\Handler\FingersCrossed\ActivationStrategyInterface;
+use Monolog\Logger;
+use Monolog\ResettableInterface;
+use Monolog\Formatter\FormatterInterface;
+use 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
+ *
+ * @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.');
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FirePHPHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FirePHPHandler.php
new file mode 100755
index 0000000..72718de
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FirePHPHandler.php
@@ -0,0 +1,180 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\WildfireFormatter;
+use Monolog\Formatter\FormatterInterface;
+
+/**
+ * Simple FirePHP Handler (http://www.firephp.org/), which uses the Wildfire protocol.
+ *
+ * @author Eric Clemmons (@ericclemmons)
+ *
+ * @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 $meta Wildfire Plugin, Protocol & Structure Indexes
+ * @param string $message Log message
+ *
+ * @return array Complete header string ready for the client as key and message as value
+ *
+ * @phpstan-return non-empty-array
+ */
+ 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
+ *
+ * @phpstan-return non-empty-array
+ *
+ * @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
+ */
+ 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']);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FleepHookHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FleepHookHandler.php
new file mode 100755
index 0000000..85c95b9
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FleepHookHandler.php
@@ -0,0 +1,135 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LineFormatter;
+use 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
+ *
+ * @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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FlowdockHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FlowdockHandler.php
new file mode 100755
index 0000000..5715d58
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FlowdockHandler.php
@@ -0,0 +1,133 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Utils;
+use Monolog\Formatter\FlowdockFormatter;
+use 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
+ * @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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FormattableHandlerInterface.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FormattableHandlerInterface.php
new file mode 100755
index 0000000..fc1693c
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FormattableHandlerInterface.php
@@ -0,0 +1,37 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+
+/**
+ * Interface to describe loggers that have a formatter
+ *
+ * @author Jordi Boggiano
+ */
+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;
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FormattableHandlerTrait.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FormattableHandlerTrait.php
new file mode 100755
index 0000000..b60bdce
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/FormattableHandlerTrait.php
@@ -0,0 +1,60 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LineFormatter;
+
+/**
+ * Helper trait for implementing FormattableInterface
+ *
+ * @author Jordi Boggiano
+ */
+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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/GelfHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/GelfHandler.php
new file mode 100755
index 0000000..4ff26c4
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/GelfHandler.php
@@ -0,0 +1,57 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Gelf\PublisherInterface;
+use Monolog\Logger;
+use Monolog\Formatter\GelfMessageFormatter;
+use Monolog\Formatter\FormatterInterface;
+
+/**
+ * Handler to send messages to a Graylog2 (http://www.graylog2.org) server
+ *
+ * @author Matt Lehner
+ * @author Benjamin Zikarsky
+ */
+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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/GroupHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/GroupHandler.php
new file mode 100755
index 0000000..3c9dc4b
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/GroupHandler.php
@@ -0,0 +1,132 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\ResettableInterface;
+
+/**
+ * Forwards records to multiple handlers
+ *
+ * @author Lenar Lõhmus
+ *
+ * @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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Handler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Handler.php
new file mode 100755
index 0000000..34b4935
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Handler.php
@@ -0,0 +1,62 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+/**
+ * Base Handler class providing basic close() support as well as handleBatch
+ *
+ * @author Jordi Boggiano
+ */
+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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/HandlerInterface.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/HandlerInterface.php
new file mode 100755
index 0000000..affcc51
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/HandlerInterface.php
@@ -0,0 +1,85 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+/**
+ * Interface that all Monolog Handlers must implement
+ *
+ * @author Jordi Boggiano
+ *
+ * @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;
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/HandlerWrapper.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/HandlerWrapper.php
new file mode 100755
index 0000000..d4351b9
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/HandlerWrapper.php
@@ -0,0 +1,136 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\ResettableInterface;
+use 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
+ */
+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();
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/IFTTTHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/IFTTTHandler.php
new file mode 100755
index 0000000..000ccea
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/IFTTTHandler.php
@@ -0,0 +1,74 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use 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
+ */
+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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/InsightOpsHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/InsightOpsHandler.php
new file mode 100755
index 0000000..71f64a2
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/InsightOpsHandler.php
@@ -0,0 +1,76 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+
+/**
+ * Inspired on LogEntriesHandler.
+ *
+ * @author Robert Kaufmann III
+ * @author Gabriel Machado
+ */
+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'];
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogEntriesHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogEntriesHandler.php
new file mode 100755
index 0000000..25fcd15
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogEntriesHandler.php
@@ -0,0 +1,70 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+
+/**
+ * @author Robert Kaufmann III
+ */
+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'];
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogglyHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogglyHandler.php
new file mode 100755
index 0000000..6d13db3
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogglyHandler.php
@@ -0,0 +1,160 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LogglyFormatter;
+use function array_key_exists;
+use CurlHandle;
+
+/**
+ * Sends errors to Loggly.
+ *
+ * @author Przemek Sobstel
+ * @author Adam Pancutt
+ * @author Gregory Barchard
+ */
+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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogmaticHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogmaticHandler.php
new file mode 100755
index 0000000..859a469
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/LogmaticHandler.php
@@ -0,0 +1,106 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LogmaticFormatter;
+
+/**
+ * @author Julien Breux
+ */
+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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MailHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MailHandler.php
new file mode 100755
index 0000000..97f3432
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MailHandler.php
@@ -0,0 +1,95 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\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
+ */
+ abstract protected 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 $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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MandrillHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MandrillHandler.php
new file mode 100755
index 0000000..3003500
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MandrillHandler.php
@@ -0,0 +1,83 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Swift;
+use Swift_Message;
+
+/**
+ * MandrillHandler uses cURL to send the emails to the Mandrill API
+ *
+ * @author Adam Nicholson
+ */
+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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MissingExtensionException.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MissingExtensionException.php
new file mode 100755
index 0000000..3965aee
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MissingExtensionException.php
@@ -0,0 +1,21 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+/**
+ * Exception can be thrown if an extension for a handler is missing
+ *
+ * @author Christian Bergau
+ */
+class MissingExtensionException extends \Exception
+{
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MongoDBHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MongoDBHandler.php
new file mode 100755
index 0000000..3063091
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/MongoDBHandler.php
@@ -0,0 +1,86 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use MongoDB\Driver\BulkWrite;
+use MongoDB\Driver\Manager;
+use MongoDB\Client;
+use Monolog\Logger;
+use Monolog\Formatter\FormatterInterface;
+use 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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NativeMailerHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NativeMailerHandler.php
new file mode 100755
index 0000000..0c0a3bd
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NativeMailerHandler.php
@@ -0,0 +1,174 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Formatter\LineFormatter;
+
+/**
+ * NativeMailerHandler uses the mail() function to send the emails
+ *
+ * @author Christophe Coevoet
+ * @author Mark Garrett
+ */
+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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NewRelicHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NewRelicHandler.php
new file mode 100755
index 0000000..114d749
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NewRelicHandler.php
@@ -0,0 +1,199 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Utils;
+use Monolog\Formatter\NormalizerFormatter;
+use 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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NoopHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NoopHandler.php
new file mode 100755
index 0000000..1ddf0be
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NoopHandler.php
@@ -0,0 +1,40 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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
+ */
+class NoopHandler extends Handler
+{
+ /**
+ * {@inheritDoc}
+ */
+ public function isHandling(array $record): bool
+ {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function handle(array $record): bool
+ {
+ return false;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NullHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NullHandler.php
new file mode 100755
index 0000000..e75ee0c
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/NullHandler.php
@@ -0,0 +1,60 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use 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
+ *
+ * @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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/OverflowHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/OverflowHandler.php
new file mode 100755
index 0000000..22068c9
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/OverflowHandler.php
@@ -0,0 +1,149 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use 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
+ */
+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.');
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PHPConsoleHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PHPConsoleHandler.php
new file mode 100755
index 0000000..23a1d11
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PHPConsoleHandler.php
@@ -0,0 +1,263 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\LineFormatter;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Logger;
+use Monolog\Utils;
+use PhpConsole\Connector;
+use PhpConsole\Handler as VendorPhpConsoleHandler;
+use 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 */
+ private $options = [
+ 'enabled' => true, // bool Is PHP Console server enabled
+ 'classesPartialsTraceIgnore' => ['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, // \PhpConsole\Storage|null Fixes problem with custom $_SESSION handler(see http://goo.gl/Ne8juJ)
+ ];
+
+ /** @var Connector */
+ private $connector;
+
+ /**
+ * @param array $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('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 $options
+ *
+ * @return array
+ */
+ 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
+ */
+ 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%');
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessHandler.php
new file mode 100755
index 0000000..8a8cf1b
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessHandler.php
@@ -0,0 +1,191 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+
+/**
+ * Stores to STDIN of any process, specified by a command.
+ *
+ * Usage example:
+ *
+ * $log = new Logger('myLogger');
+ * $log->pushHandler(new ProcessHandler('/usr/bin/php /var/www/monolog/someScript.php'));
+ *
+ *
+ * @author Kolja Zuelsdorf
+ */
+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
+ */
+ 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'], // STDERR is a pipe to catch the any errors
+ ];
+
+ /**
+ * @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;
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessableHandlerInterface.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessableHandlerInterface.php
new file mode 100755
index 0000000..3adec7a
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessableHandlerInterface.php
@@ -0,0 +1,44 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Processor\ProcessorInterface;
+
+/**
+ * Interface to describe loggers that have processors
+ *
+ * @author Jordi Boggiano
+ *
+ * @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;
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessableHandlerTrait.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessableHandlerTrait.php
new file mode 100755
index 0000000..9ef6e30
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ProcessableHandlerTrait.php
@@ -0,0 +1,77 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\ResettableInterface;
+use Monolog\Processor\ProcessorInterface;
+
+/**
+ * Helper trait for implementing ProcessableInterface
+ *
+ * @author Jordi Boggiano
+ *
+ * @phpstan-import-type Record from \Monolog\Logger
+ */
+trait ProcessableHandlerTrait
+{
+ /**
+ * @var callable[]
+ * @phpstan-var array
+ */
+ 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();
+ }
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PsrHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PsrHandler.php
new file mode 100755
index 0000000..36e19cc
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PsrHandler.php
@@ -0,0 +1,95 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Psr\Log\LoggerInterface;
+use 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
+ */
+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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PushoverHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PushoverHandler.php
new file mode 100755
index 0000000..fed2303
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/PushoverHandler.php
@@ -0,0 +1,246 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Utils;
+use Psr\Log\LogLevel;
+
+/**
+ * Sends notifications through the pushover api to mobile phones
+ *
+ * @author Sebastian Göttschkes
+ * @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 */
+ 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
+ */
+ 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 $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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RedisHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RedisHandler.php
new file mode 100755
index 0000000..91d16ea
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RedisHandler.php
@@ -0,0 +1,101 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\LineFormatter;
+use Monolog\Formatter\FormatterInterface;
+use 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
+ *
+ * @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 \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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RedisPubSubHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RedisPubSubHandler.php
new file mode 100755
index 0000000..7789309
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RedisPubSubHandler.php
@@ -0,0 +1,67 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\LineFormatter;
+use Monolog\Formatter\FormatterInterface;
+use 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
+ */
+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 \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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RollbarHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RollbarHandler.php
new file mode 100755
index 0000000..adcc939
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RollbarHandler.php
@@ -0,0 +1,131 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Rollbar\RollbarLogger;
+use Throwable;
+use 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
+ */
+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();
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RotatingFileHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RotatingFileHandler.php
new file mode 100755
index 0000000..17745d2
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/RotatingFileHandler.php
@@ -0,0 +1,207 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use InvalidArgumentException;
+use Monolog\Logger;
+use 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
+ * @author Jordi Boggiano
+ */
+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 should rotate (once per day)
+ if (null === $this->mustRotate) {
+ $this->mustRotate = null === $this->url || !file_exists($this->url);
+ }
+
+ if ($this->nextRotation <= $record['datetime']) {
+ $this->mustRotate = true;
+ $this->close();
+ }
+
+ parent::write($record);
+ }
+
+ /**
+ * Rotates the files.
+ */
+ protected function rotate(): void
+ {
+ // update filename
+ $this->url = $this->getTimedFilename();
+ $this->nextRotation = new \DateTimeImmutable('tomorrow');
+
+ // 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();
+ }
+ }
+
+ $this->mustRotate = false;
+ }
+
+ 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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SamplingHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SamplingHandler.php
new file mode 100755
index 0000000..c128a32
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SamplingHandler.php
@@ -0,0 +1,132 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+
+/**
+ * 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
+ * @author Kunal Mehta
+ *
+ * @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.');
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SendGridHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SendGridHandler.php
new file mode 100755
index 0000000..1280ee7
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SendGridHandler.php
@@ -0,0 +1,102 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use 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
+ */
+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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Slack/SlackRecord.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Slack/SlackRecord.php
new file mode 100755
index 0000000..71a4109
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/Slack/SlackRecord.php
@@ -0,0 +1,387 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler\Slack;
+
+use Monolog\Logger;
+use Monolog\Utils;
+use Monolog\Formatter\NormalizerFormatter;
+use Monolog\Formatter\FormatterInterface;
+
+/**
+ * Slack record utility helping to log to Slack webhooks or API.
+ *
+ * @author Greg Kedzierski
+ * @author Haralan Dobrev
+ * @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
+ */
+ 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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SlackHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SlackHandler.php
new file mode 100755
index 0000000..a648513
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SlackHandler.php
@@ -0,0 +1,256 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Logger;
+use Monolog\Utils;
+use Monolog\Handler\Slack\SlackRecord;
+
+/**
+ * Sends notifications through Slack API
+ *
+ * @author Greg Kedzierski
+ * @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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SlackWebhookHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SlackWebhookHandler.php
new file mode 100755
index 0000000..8ae3c78
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SlackWebhookHandler.php
@@ -0,0 +1,130 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Logger;
+use Monolog\Utils;
+use Monolog\Handler\Slack\SlackRecord;
+
+/**
+ * Sends notifications through Slack Webhooks
+ *
+ * @author Haralan Dobrev
+ * @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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SocketHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SocketHandler.php
new file mode 100755
index 0000000..21701af
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SocketHandler.php
@@ -0,0 +1,448 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+
+/**
+ * Stores to any socket - uses fsockopen() or pfsockopen().
+ *
+ * @author Pablo de Leon Belloc
+ * @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) * 1e6);
+
+ 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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SqsHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SqsHandler.php
new file mode 100755
index 0000000..dcf282b
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SqsHandler.php
@@ -0,0 +1,62 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Aws\Sqs\SqsClient;
+use Monolog\Logger;
+use Monolog\Utils;
+
+/**
+ * Writes to any sqs queue.
+ *
+ * @author Martijn van Calker
+ */
+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,
+ ]);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/StreamHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/StreamHandler.php
new file mode 100755
index 0000000..82c048e
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/StreamHandler.php
@@ -0,0 +1,224 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Utils;
+
+/**
+ * Stores to any stream resource
+ *
+ * Can be used to store into php://stderr, remote and local files, etc.
+ *
+ * @author Jordi Boggiano
+ *
+ * @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 true|null */
+ private $dirCreated = null;
+
+ /**
+ * @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
+ *
+ * @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)
+ {
+ 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->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([$this, 'customErrorHandler']);
+ try {
+ $stream = fopen($url, 'a');
+ 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->streamWrite($stream, $record);
+
+ 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)\(.*?\): }', '', $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([$this, 'customErrorHandler']);
+ $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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SwiftMailerHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SwiftMailerHandler.php
new file mode 100755
index 0000000..fae9251
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SwiftMailerHandler.php
@@ -0,0 +1,115 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Utils;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LineFormatter;
+use Swift_Message;
+use 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(\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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SymfonyMailerHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SymfonyMailerHandler.php
new file mode 100755
index 0000000..130e6f1
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SymfonyMailerHandler.php
@@ -0,0 +1,111 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\Utils;
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\LineFormatter;
+use Symfony\Component\Mailer\MailerInterface;
+use Symfony\Component\Mailer\Transport\TransportInterface;
+use Symfony\Component\Mime\Email;
+
+/**
+ * SymfonyMailerHandler uses Symfony's Mailer component to send the emails
+ *
+ * @author Jordi Boggiano
+ *
+ * @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());
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogHandler.php
new file mode 100755
index 0000000..1d543b7
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogHandler.php
@@ -0,0 +1,68 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use 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
+ */
+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']);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogUdp/UdpSocket.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogUdp/UdpSocket.php
new file mode 100755
index 0000000..dbd8ef6
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogUdp/UdpSocket.php
@@ -0,0 +1,88 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler\SyslogUdp;
+
+use 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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogUdpHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogUdpHandler.php
new file mode 100755
index 0000000..deaa19f
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/SyslogUdpHandler.php
@@ -0,0 +1,150 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use DateTimeInterface;
+use Monolog\Logger;
+use Monolog\Handler\SyslogUdp\UdpSocket;
+use Monolog\Utils;
+
+/**
+ * A Handler for logging to a remote syslogd server.
+ *
+ * @author Jesper Skovgaard Nielsen
+ * @author Dominik Kukacka
+ */
+class SyslogUdpHandler extends AbstractSyslogHandler
+{
+ const RFC3164 = 0;
+ const RFC5424 = 1;
+ const RFC5424e = 2;
+
+ /** @var array */
+ 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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/TelegramBotHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/TelegramBotHandler.php
new file mode 100755
index 0000000..8912eba
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/TelegramBotHandler.php
@@ -0,0 +1,274 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use RuntimeException;
+use Monolog\Logger;
+use 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
+ *
+ * @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', // legacy mode without underline and strikethrough, use MarkdownV2 instead
+ ];
+
+ /**
+ * 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);
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/TestHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/TestHandler.php
new file mode 100755
index 0000000..0986da2
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/TestHandler.php
@@ -0,0 +1,231 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Psr\Log\LogLevel;
+
+/**
+ * Used for testing purposes.
+ *
+ * It records all records and gives you access to them for verification.
+ *
+ * @author Jordi Boggiano
+ *
+ * @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 */
+ 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('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 . '()');
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/WebRequestRecognizerTrait.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/WebRequestRecognizerTrait.php
new file mode 100755
index 0000000..c818352
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/WebRequestRecognizerTrait.php
@@ -0,0 +1,24 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/WhatFailureGroupHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/WhatFailureGroupHandler.php
new file mode 100755
index 0000000..b6d3d3b
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/WhatFailureGroupHandler.php
@@ -0,0 +1,81 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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
+ *
+ * @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?
+ }
+ }
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ZendMonitorHandler.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ZendMonitorHandler.php
new file mode 100755
index 0000000..ddd46d8
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Handler/ZendMonitorHandler.php
@@ -0,0 +1,101 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog\Handler;
+
+use Monolog\Formatter\FormatterInterface;
+use Monolog\Formatter\NormalizerFormatter;
+use Monolog\Logger;
+
+/**
+ * Handler sending logs to Zend Monitor
+ *
+ * @author Christian Bergau
+ * @author Jason Davis
+ *
+ * @phpstan-import-type FormattedRecord from AbstractProcessingHandler
+ */
+class ZendMonitorHandler extends AbstractProcessingHandler
+{
+ /**
+ * Monolog level / ZendMonitor Custom Event priority map
+ *
+ * @var array
+ */
+ protected $levelMap = [];
+
+ /**
+ * @throws MissingExtensionException
+ */
+ public function __construct($level = Logger::DEBUG, bool $bubble = true)
+ {
+ if (!function_exists('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 => \ZEND_MONITOR_EVENT_SEVERITY_INFO,
+ Logger::INFO => \ZEND_MONITOR_EVENT_SEVERITY_INFO,
+ Logger::NOTICE => \ZEND_MONITOR_EVENT_SEVERITY_INFO,
+ Logger::WARNING => \ZEND_MONITOR_EVENT_SEVERITY_WARNING,
+ Logger::ERROR => \ZEND_MONITOR_EVENT_SEVERITY_ERROR,
+ Logger::CRITICAL => \ZEND_MONITOR_EVENT_SEVERITY_ERROR,
+ Logger::ALERT => \ZEND_MONITOR_EVENT_SEVERITY_ERROR,
+ Logger::EMERGENCY => \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
+ */
+ public function getLevelMap(): array
+ {
+ return $this->levelMap;
+ }
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/LogRecord.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/LogRecord.php
new file mode 100755
index 0000000..702807d
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/LogRecord.php
@@ -0,0 +1,34 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace 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
+ * @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;
+}
diff --git a/服务端/SMS/vendor/monolog/monolog/src/Monolog/Logger.php b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Logger.php
new file mode 100755
index 0000000..84a2f55
--- /dev/null
+++ b/服务端/SMS/vendor/monolog/monolog/src/Monolog/Logger.php
@@ -0,0 +1,761 @@
+
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Monolog;
+
+use DateTimeZone;
+use Monolog\Handler\HandlerInterface;
+use Psr\Log\LoggerInterface;
+use Psr\Log\InvalidArgumentException;
+use 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
+ *
+ * @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 $levels Logging levels with the levels as key
+ *
+ * @phpstan-var array $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 $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, int>|null 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