Final Class Yiisoft\Log\Logger

                public function __construct(
    array $targets = [],
    ?ContextProviderInterface $contextProvider = null,
) {
    $this->setTargets($targets);
    $this->contextProvider = $contextProvider ?? new SystemContextProvider();
    register_shutdown_function(function () {
        // make regular flush before other shutdown functions, which allows session data collection and so on
        $this->flush();
        // make sure log entries written by shutdown functions are also flushed
        // ensure "flush()" is called last when there are multiple shutdown functions
        register_shutdown_function([$this, 'flush'], true);
    });
}

            

                public static function assertLevelIsString(mixed $level): void
{
    if (is_string($level)) {
        return;
    }
    throw new \Psr\Log\InvalidArgumentException(
        sprintf('The log message level must be a string, %s provided.', get_debug_type($level))
    );
}

            

                public static function assertLevelIsSupported(string $level): void
{
    if (in_array($level, self::LEVELS, true)) {
        return;
    }
    throw new \Psr\Log\InvalidArgumentException(
        sprintf(
            'Invalid log message level "%s" provided. The following values are supported: "%s".',
            $level,
            implode('", "', self::LEVELS)
        )
    );
}

            

                public static function assertLevelIsValid(mixed $level): void
{
    self::assertLevelIsString($level);
    self::assertLevelIsSupported($level);
}

            

                public function flush(bool $final = false): void
{
    $messages = $this->messages;
    // https://github.com/yiisoft/yii2/issues/5619
    // new messages could be logged while the existing ones are being handled by targets
    $this->messages = [];
    $this->dispatch($messages, $final);
}

            

                public function getTargets(): array
{
    return $this->targets;
}

            

                public function log(mixed $level, string|Stringable $message, array $context = []): void
{
    self::assertLevelIsString($level);
    $this->messages[] = new Message(
        $level,
        $message,
        array_merge($this->contextProvider->getContext(), $context),
    );
    if ($this->flushInterval > 0 && count($this->messages) >= $this->flushInterval) {
        $this->flush();
    }
}

            

                public function setExcludedTracePaths(array $excludedTracePaths): self
{
    if (!$this->contextProvider instanceof SystemContextProvider) {
        throw new RuntimeException(
            '"Logger::setExcludedTracePaths()" is unavailable when using a custom context provider.'
        );
    }
    /** @psalm-suppress DeprecatedMethod */
    $this->contextProvider->setExcludedTracePaths($excludedTracePaths);
    return $this;
}

            

                public function setFlushInterval(int $flushInterval): self
{
    $this->flushInterval = $flushInterval;
    return $this;
}

            

                public function setTraceLevel(int $traceLevel): self
{
    if (!$this->contextProvider instanceof SystemContextProvider) {
        throw new RuntimeException(
            '"Logger::setTraceLevel()" is unavailable when using a custom context provider.'
        );
    }
    /** @psalm-suppress DeprecatedMethod */
    $this->contextProvider->setTraceLevel($traceLevel);
    return $this;
}

            

                public static function validateLevel(mixed $level): string
{
    if (!is_string($level)) {
        throw new \Psr\Log\InvalidArgumentException(sprintf(
            'The log message level must be a string, %s provided.',
            get_debug_type($level)
        ));
    }
    if (!in_array($level, self::LEVELS, true)) {
        throw new \Psr\Log\InvalidArgumentException(sprintf(
            'Invalid log message level "%s" provided. The following values are supported: "%s".',
            $level,
            implode('", "', self::LEVELS)
        ));
    }
    return $level;
}