<form method="POST">
    <h3>Editing: TelegramBotHandler.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);

/*
 * This file is part of the Monolog package.
 *
 * (c) Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 *
 * 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 &lt;alexandrmazur96@gmail.com&gt;
 *
 * @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-&gt;apiKey = $apiKey;
        $this-&gt;channel = $channel;
        $this-&gt;setParseMode($parseMode);
        $this-&gt;disableWebPagePreview($disableWebPagePreview);
        $this-&gt;disableNotification($disableNotification);
        $this-&gt;splitLongMessages($splitLongMessages);
        $this-&gt;delayBetweenMessages($delayBetweenMessages);
    }

    public function setParseMode(?string $parseMode = null): self
    {
        if ($parseMode !== null &amp;&amp; !in_array($parseMode, self::AVAILABLE_PARSE_MODES)) {
            throw new \InvalidArgumentException('Unknown parseMode, use one of these: ' . implode(', ', self::AVAILABLE_PARSE_MODES) . '.');
        }

        $this-&gt;parseMode = $parseMode;

        return $this;
    }

    public function disableWebPagePreview(?bool $disableWebPagePreview = null): self
    {
        $this-&gt;disableWebPagePreview = $disableWebPagePreview;

        return $this;
    }

    public function disableNotification(?bool $disableNotification = null): self
    {
        $this-&gt;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-&gt;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-&gt;delayBetweenMessages = $delayBetweenMessages;

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function handleBatch(array $records): void
    {
        /** @var Record[] $messages */
        $messages = [];

        foreach ($records as $record) {
            if (!$this-&gt;isHandling($record)) {
                continue;
            }

            if ($this-&gt;processors) {
                /** @var Record $record */
                $record = $this-&gt;processRecord($record);
            }

            $messages[] = $record;
        }

        if (!empty($messages)) {
            $this-&gt;send((string)$this-&gt;getFormatter()-&gt;formatBatch($messages));
        }
    }

    /**
     * @inheritDoc
     */
    protected function write(array $record): void
    {
        $this-&gt;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-&gt;handleMessageLength($message);

        foreach ($messages as $key =&gt; $msg) {
            if ($this-&gt;delayBetweenMessages &amp;&amp; $key &gt; 0) {
                sleep(1);
            }

            $this-&gt;sendCurl($msg);
        }
    }

    protected function sendCurl(string $message): void
    {
        $ch = curl_init();
        $url = self::BOT_API . $this-&gt;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' =&gt; $message,
            'chat_id' =&gt; $this-&gt;channel,
            'parse_mode' =&gt; $this-&gt;parseMode,
            'disable_web_page_preview' =&gt; $this-&gt;disableWebPagePreview,
            'disable_notification' =&gt; $this-&gt;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-&gt;splitLongMessages &amp;&amp; strlen($message) &gt; self::MAX_MESSAGE_LENGTH) {
            return [Utils::substr($message, 0, self::MAX_MESSAGE_LENGTH - strlen($truncatedMarker)) . $truncatedMarker];
        }

        return str_split($message, self::MAX_MESSAGE_LENGTH);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>