glastree_on_gitea

vendor/laravel/framework/src/Illuminate/Log/Context/ContextLogProcessor.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Illuminate\Log\Context;
+
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Log\ContextLogProcessor as ContextLogProcessorContract;
+use Illuminate\Log\Context\Repository as ContextRepository;
+use Monolog\LogRecord;
+
+class ContextLogProcessor implements ContextLogProcessorContract
+{
+    /**
+     * Add contextual data to the log's "extra" parameter.
+     *
+     * @param  \Monolog\LogRecord  $record
+     * @return \Monolog\LogRecord
+     */
+    public function __invoke(LogRecord $record): LogRecord
+    {
+        $app = Container::getInstance();
+
+        if (! $app->bound(ContextRepository::class)) {
+            return $record;
+        }
+
+        return $record->with(extra: [
+            ...$record->extra,
+            ...$app->get(ContextRepository::class)->all(),
+        ]);
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/Context/ContextServiceProvider.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Illuminate\Log\Context;
+
+use Illuminate\Contracts\Log\ContextLogProcessor as ContextLogProcessorContract;
+use Illuminate\Queue\Events\JobProcessing;
+use Illuminate\Queue\Queue;
+use Illuminate\Support\Env;
+use Illuminate\Support\Facades\Context;
+use Illuminate\Support\ServiceProvider;
+
+class ContextServiceProvider extends ServiceProvider
+{
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        $this->app->scoped(Repository::class);
+
+        if ($this->app->runningInConsole()) {
+            $this->app->resolving(Repository::class, function (Repository $repository) {
+                $context = Env::get('__LARAVEL_CONTEXT');
+
+                if ($context && $context = json_decode($context, associative: true)) {
+                    $repository->hydrate($context);
+                }
+            });
+        }
+
+        $this->app->bind(ContextLogProcessorContract::class, fn () => new ContextLogProcessor());
+    }
+
+    /**
+     * Boot the application services.
+     *
+     * @return void
+     */
+    public function boot()
+    {
+        Queue::createPayloadUsing(function ($connection, $queue, $payload) {
+            /** @phpstan-ignore staticMethod.notFound */
+            $context = Context::dehydrate();
+
+            return $context === null ? $payload : [
+                ...$payload,
+                'illuminate:log:context' => $context,
+            ];
+        });
+
+        $this->app['events']->listen(function (JobProcessing $event) {
+            /** @phpstan-ignore staticMethod.notFound */
+            Context::hydrate($event->job->payload()['illuminate:log:context'] ?? null);
+        });
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/Context/Events/ContextDehydrating.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Illuminate\Log\Context\Events;
+
+class ContextDehydrating
+{
+    /**
+     * The context instance.
+     *
+     * @var \Illuminate\Log\Context\Repository
+     */
+    public $context;
+
+    /**
+     * Create a new event instance.
+     *
+     * @param  \Illuminate\Log\Context\Repository  $context
+     */
+    public function __construct($context)
+    {
+        $this->context = $context;
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/Context/Events/ContextHydrated.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Illuminate\Log\Context\Events;
+
+class ContextHydrated
+{
+    /**
+     * The context instance.
+     *
+     * @var \Illuminate\Log\Context\Repository
+     */
+    public $context;
+
+    /**
+     * Create a new event instance.
+     *
+     * @param  \Illuminate\Log\Context\Repository  $context
+     */
+    public function __construct($context)
+    {
+        $this->context = $context;
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/Context/Repository.php

@@ -0,0 +1,702 @@
+<?php
+
+namespace Illuminate\Log\Context;
+
+use __PHP_Incomplete_Class;
+use Closure;
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Database\Eloquent\ModelNotFoundException;
+use Illuminate\Log\Context\Events\ContextDehydrating as Dehydrating;
+use Illuminate\Log\Context\Events\ContextHydrated as Hydrated;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Traits\Conditionable;
+use Illuminate\Support\Traits\Macroable;
+use RuntimeException;
+use Throwable;
+
+class Repository
+{
+    use Conditionable, Macroable, SerializesModels;
+
+    /**
+     * The event dispatcher instance.
+     *
+     * @var \Illuminate\Contracts\Events\Dispatcher
+     */
+    protected $events;
+
+    /**
+     * The contextual data.
+     *
+     * @var array<string, mixed>
+     */
+    protected $data = [];
+
+    /**
+     * The hidden contextual data.
+     *
+     * @var array<string, mixed>
+     */
+    protected $hidden = [];
+
+    /**
+     * The callback that should handle unserialize exceptions.
+     *
+     * @var callable|null
+     */
+    protected static $handleUnserializeExceptionsUsing;
+
+    /**
+     * Create a new Context instance.
+     */
+    public function __construct(Dispatcher $events)
+    {
+        $this->events = $events;
+    }
+
+    /**
+     * Determine if the given key exists.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function has($key)
+    {
+        return array_key_exists($key, $this->data);
+    }
+
+    /**
+     * Determine if the given key is missing.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function missing($key)
+    {
+        return ! $this->has($key);
+    }
+
+    /**
+     * Determine if the given key exists within the hidden context data.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function hasHidden($key)
+    {
+        return array_key_exists($key, $this->hidden);
+    }
+
+    /**
+     * Determine if the given key is missing within the hidden context data.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function missingHidden($key)
+    {
+        return ! $this->hasHidden($key);
+    }
+
+    /**
+     * Retrieve all the context data.
+     *
+     * @return array<string, mixed>
+     */
+    public function all()
+    {
+        return $this->data;
+    }
+
+    /**
+     * Retrieve all the hidden context data.
+     *
+     * @return array<string, mixed>
+     */
+    public function allHidden()
+    {
+        return $this->hidden;
+    }
+
+    /**
+     * Retrieve the given key's value.
+     *
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public function get($key, $default = null)
+    {
+        return $this->data[$key] ?? value($default);
+    }
+
+    /**
+     * Retrieve the given key's hidden value.
+     *
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public function getHidden($key, $default = null)
+    {
+        return $this->hidden[$key] ?? value($default);
+    }
+
+    /**
+     * Retrieve the given key's value and then forget it.
+     *
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public function pull($key, $default = null)
+    {
+        return tap($this->get($key, $default), function () use ($key) {
+            $this->forget($key);
+        });
+    }
+
+    /**
+     * Retrieve the given key's hidden value and then forget it.
+     *
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public function pullHidden($key, $default = null)
+    {
+        return tap($this->getHidden($key, $default), function () use ($key) {
+            $this->forgetHidden($key);
+        });
+    }
+
+    /**
+     * Retrieve only the values of the given keys.
+     *
+     * @param  array<int, string>  $keys
+     * @return array<string, mixed>
+     */
+    public function only($keys)
+    {
+        return array_intersect_key($this->data, array_flip($keys));
+    }
+
+    /**
+     * Retrieve only the hidden values of the given keys.
+     *
+     * @param  array<int, string>  $keys
+     * @return array<string, mixed>
+     */
+    public function onlyHidden($keys)
+    {
+        return array_intersect_key($this->hidden, array_flip($keys));
+    }
+
+    /**
+     * Retrieve all values except those with the given keys.
+     *
+     * @param  array<int, string>  $keys
+     * @return array<string, mixed>
+     */
+    public function except($keys)
+    {
+        return array_diff_key($this->data, array_flip($keys));
+    }
+
+    /**
+     * Retrieve all hidden values except those with the given keys.
+     *
+     * @param  array<int, string>  $keys
+     * @return array<string, mixed>
+     */
+    public function exceptHidden($keys)
+    {
+        return array_diff_key($this->hidden, array_flip($keys));
+    }
+
+    /**
+     * Add a context value.
+     *
+     * @param  string|array<string, mixed>  $key
+     * @param  mixed  $value
+     * @return $this
+     */
+    public function add($key, $value = null)
+    {
+        $this->data = array_merge(
+            $this->data,
+            is_array($key) ? $key : [$key => $value]
+        );
+
+        return $this;
+    }
+
+    /**
+     * Add a hidden context value.
+     *
+     * @param  string|array<string, mixed>  $key
+     * @param  mixed  $value
+     * @return $this
+     */
+    public function addHidden($key, #[\SensitiveParameter] $value = null)
+    {
+        $this->hidden = array_merge(
+            $this->hidden,
+            is_array($key) ? $key : [$key => $value]
+        );
+
+        return $this;
+    }
+
+    /**
+     * Add a context value if it does not exist yet, and return the value.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return mixed
+     */
+    public function remember($key, $value)
+    {
+        if ($this->has($key)) {
+            return $this->get($key);
+        }
+
+        return tap(value($value), function ($value) use ($key) {
+            $this->add($key, $value);
+        });
+    }
+
+    /**
+     * Add a hidden context value if it does not exist yet, and return the value.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return mixed
+     */
+    public function rememberHidden($key, #[\SensitiveParameter] $value)
+    {
+        if ($this->hasHidden($key)) {
+            return $this->getHidden($key);
+        }
+
+        return tap(value($value), function ($value) use ($key) {
+            $this->addHidden($key, $value);
+        });
+    }
+
+    /**
+     * Forget the given context key.
+     *
+     * @param  string|array<int, string>  $key
+     * @return $this
+     */
+    public function forget($key)
+    {
+        foreach ((array) $key as $k) {
+            unset($this->data[$k]);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Forget the given hidden context key.
+     *
+     * @param  string|array<int, string>  $key
+     * @return $this
+     */
+    public function forgetHidden($key)
+    {
+        foreach ((array) $key as $k) {
+            unset($this->hidden[$k]);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add a context value if it does not exist yet.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return $this
+     */
+    public function addIf($key, $value)
+    {
+        if (! $this->has($key)) {
+            $this->add($key, $value);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add a hidden context value if it does not exist yet.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return $this
+     */
+    public function addHiddenIf($key, #[\SensitiveParameter] $value)
+    {
+        if (! $this->hasHidden($key)) {
+            $this->addHidden($key, $value);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Push the given values onto the key's stack.
+     *
+     * @param  string  $key
+     * @param  mixed  ...$values
+     * @return $this
+     *
+     * @throws \RuntimeException
+     */
+    public function push($key, ...$values)
+    {
+        if (! $this->isStackable($key)) {
+            throw new RuntimeException("Unable to push value onto context stack for key [{$key}].");
+        }
+
+        $this->data[$key] = [
+            ...$this->data[$key] ?? [],
+            ...$values,
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Pop the latest value from the key's stack.
+     *
+     * @param  string  $key
+     * @return mixed
+     *
+     * @throws \RuntimeException
+     */
+    public function pop($key)
+    {
+        if (! $this->isStackable($key) || ! count($this->data[$key])) {
+            throw new RuntimeException("Unable to pop value from context stack for key [{$key}].");
+        }
+
+        return array_pop($this->data[$key]);
+    }
+
+    /**
+     * Push the given hidden values onto the key's stack.
+     *
+     * @param  string  $key
+     * @param  mixed  ...$values
+     * @return $this
+     *
+     * @throws \RuntimeException
+     */
+    public function pushHidden($key, ...$values)
+    {
+        if (! $this->isHiddenStackable($key)) {
+            throw new RuntimeException("Unable to push value onto hidden context stack for key [{$key}].");
+        }
+
+        $this->hidden[$key] = [
+            ...$this->hidden[$key] ?? [],
+            ...$values,
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Pop the latest hidden value from the key's stack.
+     *
+     * @param  string  $key
+     * @return mixed
+     *
+     * @throws \RuntimeException
+     */
+    public function popHidden($key)
+    {
+        if (! $this->isHiddenStackable($key) || ! count($this->hidden[$key])) {
+            throw new RuntimeException("Unable to pop value from hidden context stack for key [{$key}].");
+        }
+
+        return array_pop($this->hidden[$key]);
+    }
+
+    /**
+     * Increment a context counter.
+     *
+     * @param  string  $key
+     * @param  int  $amount
+     * @return $this
+     */
+    public function increment(string $key, int $amount = 1)
+    {
+        $this->add(
+            $key,
+            (int) $this->get($key, 0) + $amount,
+        );
+
+        return $this;
+    }
+
+    /**
+     * Decrement a context counter.
+     *
+     * @param  string  $key
+     * @param  int  $amount
+     * @return $this
+     */
+    public function decrement(string $key, int $amount = 1)
+    {
+        return $this->increment($key, $amount * -1);
+    }
+
+    /**
+     * Determine if the given value is in the given stack.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  bool  $strict
+     * @return bool
+     *
+     * @throws \RuntimeException
+     */
+    public function stackContains(string $key, mixed $value, bool $strict = false): bool
+    {
+        if (! $this->isStackable($key)) {
+            throw new RuntimeException("Given key [{$key}] is not a stack.");
+        }
+
+        if (! array_key_exists($key, $this->data)) {
+            return false;
+        }
+
+        if ($value instanceof Closure) {
+            return (new Collection($this->data[$key]))->contains($value);
+        }
+
+        return in_array($value, $this->data[$key], $strict);
+    }
+
+    /**
+     * Determine if the given value is in the given hidden stack.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  bool  $strict
+     * @return bool
+     *
+     * @throws \RuntimeException
+     */
+    public function hiddenStackContains(string $key, mixed $value, bool $strict = false): bool
+    {
+        if (! $this->isHiddenStackable($key)) {
+            throw new RuntimeException("Given key [{$key}] is not a stack.");
+        }
+
+        if (! array_key_exists($key, $this->hidden)) {
+            return false;
+        }
+
+        if ($value instanceof Closure) {
+            return (new Collection($this->hidden[$key]))->contains($value);
+        }
+
+        return in_array($value, $this->hidden[$key], $strict);
+    }
+
+    /**
+     * Determine if a given key can be used as a stack.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    protected function isStackable($key)
+    {
+        return ! $this->has($key) ||
+            (is_array($this->data[$key]) && array_is_list($this->data[$key]));
+    }
+
+    /**
+     * Determine if a given key can be used as a hidden stack.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    protected function isHiddenStackable($key)
+    {
+        return ! $this->hasHidden($key) ||
+            (is_array($this->hidden[$key]) && array_is_list($this->hidden[$key]));
+    }
+
+    /**
+     * @template TReturn of mixed
+     *
+     * Run the callback function with the given context values and restore the original context state when complete.
+     *
+     * @param  (callable(): TReturn)  $callback
+     * @param  array<string, mixed>  $data
+     * @param  array<string, mixed>  $hidden
+     * @return TReturn
+     *
+     * @throws \Throwable
+     */
+    public function scope(callable $callback, array $data = [], array $hidden = [])
+    {
+        $dataBefore = $this->data;
+        $hiddenBefore = $this->hidden;
+
+        if ($data !== []) {
+            $this->add($data);
+        }
+
+        if ($hidden !== []) {
+            $this->addHidden($hidden);
+        }
+
+        try {
+            return $callback();
+        } finally {
+            $this->data = $dataBefore;
+            $this->hidden = $hiddenBefore;
+        }
+    }
+
+    /**
+     * Determine if the repository is empty.
+     *
+     * @return bool
+     */
+    public function isEmpty()
+    {
+        return $this->all() === [] && $this->allHidden() === [];
+    }
+
+    /**
+     * Execute the given callback when context is about to be dehydrated.
+     *
+     * @param  (callable(static): void)  $callback
+     * @return $this
+     */
+    public function dehydrating($callback)
+    {
+        $this->events->listen(fn (Dehydrating $event) => $callback($event->context));
+
+        return $this;
+    }
+
+    /**
+     * Execute the given callback when context has been hydrated.
+     *
+     * @param  (callable(static): void)  $callback
+     * @return $this
+     */
+    public function hydrated($callback)
+    {
+        $this->events->listen(fn (Hydrated $event) => $callback($event->context));
+
+        return $this;
+    }
+
+    /**
+     * Handle unserialize exceptions using the given callback.
+     *
+     * @param  callable|null  $callback
+     * @return $this
+     */
+    public function handleUnserializeExceptionsUsing($callback)
+    {
+        static::$handleUnserializeExceptionsUsing = $callback;
+
+        return $this;
+    }
+
+    /**
+     * Flush all context data.
+     *
+     * @return $this
+     */
+    public function flush()
+    {
+        $this->data = [];
+        $this->hidden = [];
+
+        return $this;
+    }
+
+    /**
+     * Dehydrate the context data.
+     *
+     * @internal
+     *
+     * @return ?array
+     */
+    public function dehydrate()
+    {
+        $instance = (new static($this->events))
+            ->add($this->all())
+            ->addHidden($this->allHidden());
+
+        $instance->events->dispatch(new Dehydrating($instance));
+
+        $serialize = fn ($value) => serialize($instance->getSerializedPropertyValue($value, withRelations: false));
+
+        return $instance->isEmpty() ? null : [
+            'data' => array_map($serialize, $instance->all()),
+            'hidden' => array_map($serialize, $instance->allHidden()),
+        ];
+    }
+
+    /**
+     * Hydrate the context instance.
+     *
+     * @internal
+     *
+     * @param  ?array  $context
+     * @return $this
+     *
+     * @throws \RuntimeException
+     */
+    public function hydrate($context)
+    {
+        $unserialize = function ($value, $key, $hidden) {
+            try {
+                return tap($this->getRestoredPropertyValue(unserialize($value)), function ($value) {
+                    if ($value instanceof __PHP_Incomplete_Class) {
+                        throw new RuntimeException('Value is incomplete class: '.json_encode($value));
+                    }
+                });
+            } catch (Throwable $e) {
+                if (static::$handleUnserializeExceptionsUsing !== null) {
+                    return (static::$handleUnserializeExceptionsUsing)($e, $key, $value, $hidden);
+                }
+
+                if ($e instanceof ModelNotFoundException) {
+                    if (function_exists('report')) {
+                        report($e);
+                    }
+
+                    return null;
+                }
+
+                throw $e;
+            }
+        };
+
+        [$data, $hidden] = [
+            (new Collection($context['data'] ?? []))->map(fn ($value, $key) => $unserialize($value, $key, false))->all(),
+            (new Collection($context['hidden'] ?? []))->map(fn ($value, $key) => $unserialize($value, $key, true))->all(),
+        ];
+
+        $this->events->dispatch(new Hydrated(
+            $this->flush()->add($data)->addHidden($hidden)
+        ));
+
+        return $this;
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/Events/MessageLogged.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Illuminate\Log\Events;
+
+class MessageLogged
+{
+    /**
+     * Create a new event instance.
+     *
+     * @param  "emergency"|"alert"|"critical"|"error"|"warning"|"notice"|"info"|"debug"  $level  The log "level".
+     * @param  string  $message  The log message.
+     * @param  array  $context  The log context.
+     */
+    public function __construct(
+        public $level,
+        public $message,
+        public array $context = [],
+    ) {
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/Formatters/JsonFormatter.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Illuminate\Log\Formatters;
+
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Debug\ExceptionHandler;
+use Monolog\Formatter\JsonFormatter as MonologJsonFormatter;
+use Throwable;
+
+class JsonFormatter extends MonologJsonFormatter
+{
+    #[\Override]
+    protected function normalizeException(Throwable $e, int $depth = 0): array
+    {
+        $response = parent::normalizeException($e, $depth);
+
+        try {
+            $handler = Container::getInstance()->make(ExceptionHandler::class);
+        } catch (Throwable) {
+            return array_merge($this->getExceptionContext($e, $depth), $response);
+        }
+
+        if ((! method_exists($handler, 'isReporting')) || ! $handler->isReporting($e)) {
+            if (method_exists($handler, 'buildContextForException')
+                && is_array($normalizedHandlerExceptionContext = $this->normalize($handler->buildContextForException($e), $depth + 1))
+            ) {
+                $response = array_merge(
+                    $normalizedHandlerExceptionContext,
+                    $response
+                );
+            } elseif (method_exists($e, 'context')) {
+                $response = array_merge($this->getExceptionContext($e, $depth), $response);
+            }
+        }
+
+        return $response;
+    }
+
+    /**
+     * Extract the context from the exception if available.
+     *
+     * @return array<array-key, mixed>
+     */
+    protected function getExceptionContext(Throwable $e, int $depth): array
+    {
+        if (! method_exists($e, 'context')) {
+            return [];
+        }
+
+        try {
+            $exceptionContext = $this->normalize($e->context(), $depth + 1);
+        } catch (Throwable) {
+            return [];
+        }
+
+        return is_array($exceptionContext) ? $exceptionContext : [];
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Taylor Otwell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/laravel/framework/src/Illuminate/Log/LogManager.php

@@ -0,0 +1,807 @@
+<?php
+
+namespace Illuminate\Log;
+
+use Closure;
+use Illuminate\Contracts\Log\ContextLogProcessor;
+use Illuminate\Support\Collection;
+use Illuminate\Support\RebindsCallbacksToSelf;
+use Illuminate\Support\Str;
+use InvalidArgumentException;
+use Monolog\Formatter\LineFormatter;
+use Monolog\Handler\ErrorLogHandler;
+use Monolog\Handler\FingersCrossedHandler;
+use Monolog\Handler\FormattableHandlerInterface;
+use Monolog\Handler\HandlerInterface;
+use Monolog\Handler\RotatingFileHandler;
+use Monolog\Handler\SlackWebhookHandler;
+use Monolog\Handler\StreamHandler;
+use Monolog\Handler\SyslogHandler;
+use Monolog\Handler\WhatFailureGroupHandler;
+use Monolog\Logger as Monolog;
+use Monolog\Processor\ProcessorInterface;
+use Monolog\Processor\PsrLogMessageProcessor;
+use Psr\Log\LoggerInterface;
+use ReflectionException;
+use RuntimeException;
+use Throwable;
+
+use function Illuminate\Support\enum_value;
+
+/**
+ * @mixin \Illuminate\Log\Logger
+ */
+class LogManager implements LoggerInterface
+{
+    use ParsesLogConfiguration, RebindsCallbacksToSelf;
+
+    /**
+     * The application instance.
+     *
+     * @var \Illuminate\Contracts\Foundation\Application
+     */
+    protected $app;
+
+    /**
+     * The array of resolved channels.
+     *
+     * @var array
+     */
+    protected $channels = [];
+
+    /**
+     * The context shared across channels and stacks.
+     *
+     * @var array
+     */
+    protected $sharedContext = [];
+
+    /**
+     * The registered custom driver creators.
+     *
+     * @var array
+     */
+    protected $customCreators = [];
+
+    /**
+     * The standard date format to use when writing logs.
+     *
+     * @var string
+     */
+    protected $dateFormat = 'Y-m-d H:i:s';
+
+    /**
+     * Create a new Log manager instance.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     */
+    public function __construct($app)
+    {
+        $this->app = $app;
+    }
+
+    /**
+     * Build an on-demand log channel.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    public function build(array $config)
+    {
+        unset($this->channels['ondemand']);
+
+        return $this->get('ondemand', $config);
+    }
+
+    /**
+     * Create a new, on-demand aggregate logger instance.
+     *
+     * @param  array  $channels
+     * @param  string|null  $channel
+     * @return \Psr\Log\LoggerInterface
+     */
+    public function stack(array $channels, $channel = null)
+    {
+        return (new Logger(
+            $this->createStackDriver(compact('channels', 'channel')),
+            $this->app['events']
+        ))->withContext($this->sharedContext);
+    }
+
+    /**
+     * Get a log channel instance.
+     *
+     * @param  \UnitEnum|string|null  $channel
+     * @return \Psr\Log\LoggerInterface
+     */
+    public function channel($channel = null)
+    {
+        return $this->driver($channel);
+    }
+
+    /**
+     * Get a log driver instance.
+     *
+     * @param  \UnitEnum|string|null  $driver
+     * @return \Psr\Log\LoggerInterface
+     */
+    public function driver($driver = null)
+    {
+        return $this->get($this->parseDriver(enum_value($driver)));
+    }
+
+    /**
+     * Attempt to get the log from the local cache.
+     *
+     * @param  string  $name
+     * @param  array|null  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function get($name, ?array $config = null)
+    {
+        try {
+            return $this->channels[$name] ?? with($this->resolve($name, $config), function ($logger) use ($name) {
+                $loggerWithContext = $this->tap(
+                    $name,
+                    new Logger($logger, $this->app['events'])
+                )->withContext($this->sharedContext);
+
+                if (method_exists($loggerWithContext->getLogger(), 'pushProcessor')) {
+                    $loggerWithContext->pushProcessor($this->app->make(ContextLogProcessor::class));
+                }
+
+                return $this->channels[$name] = $loggerWithContext;
+            });
+        } catch (Throwable $e) {
+            return tap($this->createEmergencyLogger(), function ($logger) use ($e) {
+                $logger->emergency('Unable to create configured logger. Using emergency logger.', [
+                    'exception' => $e,
+                ]);
+            });
+        }
+    }
+
+    /**
+     * Apply the configured taps for the logger.
+     *
+     * @param  string  $name
+     * @param  \Illuminate\Log\Logger  $logger
+     * @return \Illuminate\Log\Logger
+     */
+    protected function tap($name, Logger $logger)
+    {
+        foreach ($this->configurationFor($name)['tap'] ?? [] as $tap) {
+            [$class, $arguments] = $this->parseTap($tap);
+
+            $this->app->make($class)->__invoke($logger, ...explode(',', $arguments));
+        }
+
+        return $logger;
+    }
+
+    /**
+     * Parse the given tap class string into a class name and arguments string.
+     *
+     * @param  string  $tap
+     * @return array
+     */
+    protected function parseTap($tap)
+    {
+        return str_contains($tap, ':') ? explode(':', $tap, 2) : [$tap, ''];
+    }
+
+    /**
+     * Create an emergency log handler to avoid white screens of death.
+     *
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createEmergencyLogger()
+    {
+        $config = $this->configurationFor('emergency');
+
+        $handler = new StreamHandler(
+            $config['path'] ?? $this->app->storagePath().'/logs/laravel.log',
+            $this->level(['level' => 'debug'])
+        );
+
+        return new Logger(
+            new Monolog('laravel', $this->prepareHandlers([$handler])),
+            $this->app['events']
+        );
+    }
+
+    /**
+     * Resolve the given log instance by name.
+     *
+     * @param  string  $name
+     * @param  array|null  $config
+     * @return \Psr\Log\LoggerInterface
+     *
+     * @throws \InvalidArgumentException
+     */
+    protected function resolve($name, ?array $config = null)
+    {
+        $config ??= $this->configurationFor($name);
+
+        if (is_null($config)) {
+            throw new InvalidArgumentException("Log [{$name}] is not defined.");
+        }
+
+        if (isset($this->customCreators[$config['driver']])) {
+            return $this->callCustomCreator($config);
+        }
+
+        $driverMethod = 'create'.ucfirst($config['driver']).'Driver';
+
+        if (method_exists($this, $driverMethod)) {
+            return $this->{$driverMethod}($config);
+        }
+
+        throw new InvalidArgumentException("Driver [{$config['driver']}] is not supported.");
+    }
+
+    /**
+     * Call a custom driver creator.
+     *
+     * @param  array  $config
+     * @return mixed
+     */
+    protected function callCustomCreator(array $config)
+    {
+        return $this->customCreators[$config['driver']]($this->app, $config);
+    }
+
+    /**
+     * Create a custom log driver instance.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createCustomDriver(array $config)
+    {
+        $factory = is_callable($via = $config['via']) ? $via : $this->app->make($via);
+
+        return $factory($config);
+    }
+
+    /**
+     * Create an aggregate log driver instance.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createStackDriver(array $config)
+    {
+        if (is_string($config['channels'])) {
+            $config['channels'] = explode(',', $config['channels']);
+        }
+
+        $handlers = (new Collection($config['channels']))
+            ->flatMap(function ($channel) {
+                return $channel instanceof LoggerInterface
+                    ? $channel->getHandlers()
+                    : $this->channel($channel)->getHandlers();
+            })
+            ->all();
+
+        $processors = (new Collection($config['channels']))
+            ->flatMap(function ($channel) {
+                return $channel instanceof LoggerInterface
+                    ? $channel->getProcessors()
+                    : $this->channel($channel)->getProcessors();
+            })
+            ->all();
+
+        if ($config['ignore_exceptions'] ?? false) {
+            $handlers = [new WhatFailureGroupHandler($handlers)];
+        }
+
+        return new Monolog($this->parseChannel($config), $handlers, $processors);
+    }
+
+    /**
+     * Create an instance of the single file log driver.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createSingleDriver(array $config)
+    {
+        return new Monolog($this->parseChannel($config), [
+            $this->prepareHandler(
+                new StreamHandler(
+                    $config['path'], $this->level($config),
+                    $config['bubble'] ?? true, $config['permission'] ?? null, $config['locking'] ?? false
+                ), $config
+            ),
+        ], $config['replace_placeholders'] ?? false ? [new PsrLogMessageProcessor()] : []);
+    }
+
+    /**
+     * Create an instance of the daily file log driver.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createDailyDriver(array $config)
+    {
+        return new Monolog($this->parseChannel($config), [
+            $this->prepareHandler(new RotatingFileHandler(
+                $config['path'], $config['days'] ?? 7, $this->level($config),
+                $config['bubble'] ?? true, $config['permission'] ?? null, $config['locking'] ?? false
+            ), $config),
+        ], $config['replace_placeholders'] ?? false ? [new PsrLogMessageProcessor()] : []);
+    }
+
+    /**
+     * Create an instance of the Slack log driver.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createSlackDriver(array $config)
+    {
+        return new Monolog($this->parseChannel($config), [
+            $this->prepareHandler(new SlackWebhookHandler(
+                $config['url'],
+                $config['channel'] ?? null,
+                $config['username'] ?? 'Laravel',
+                $config['attachment'] ?? true,
+                $config['emoji'] ?? ':boom:',
+                $config['short'] ?? false,
+                $config['context'] ?? true,
+                $this->level($config),
+                $config['bubble'] ?? true,
+                $config['exclude_fields'] ?? []
+            ), $config),
+        ], $config['replace_placeholders'] ?? false ? [new PsrLogMessageProcessor()] : []);
+    }
+
+    /**
+     * Create an instance of the syslog log driver.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createSyslogDriver(array $config)
+    {
+        return new Monolog($this->parseChannel($config), [
+            $this->prepareHandler(new SyslogHandler(
+                Str::snake($this->app['config']['app.name'], '-'),
+                $config['facility'] ?? LOG_USER, $this->level($config)
+            ), $config),
+        ], $config['replace_placeholders'] ?? false ? [new PsrLogMessageProcessor()] : []);
+    }
+
+    /**
+     * Create an instance of the "error log" log driver.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     */
+    protected function createErrorlogDriver(array $config)
+    {
+        return new Monolog($this->parseChannel($config), [
+            $this->prepareHandler(new ErrorLogHandler(
+                $config['type'] ?? ErrorLogHandler::OPERATING_SYSTEM, $this->level($config)
+            )),
+        ], $config['replace_placeholders'] ?? false ? [new PsrLogMessageProcessor()] : []);
+    }
+
+    /**
+     * Create an instance of any handler available in Monolog.
+     *
+     * @param  array  $config
+     * @return \Psr\Log\LoggerInterface
+     *
+     * @throws \InvalidArgumentException
+     * @throws \Illuminate\Contracts\Container\BindingResolutionException
+     */
+    protected function createMonologDriver(array $config)
+    {
+        if (! is_a($config['handler'], HandlerInterface::class, true)) {
+            throw new InvalidArgumentException(
+                $config['handler'].' must be an instance of '.HandlerInterface::class
+            );
+        }
+
+        (new Collection($config['processors'] ?? []))->each(function ($processor) {
+            $processor = $processor['processor'] ?? $processor;
+
+            if (! is_a($processor, ProcessorInterface::class, true)) {
+                throw new InvalidArgumentException(
+                    $processor.' must be an instance of '.ProcessorInterface::class
+                );
+            }
+        });
+
+        $with = array_merge(
+            ['level' => $this->level($config)],
+            $config['with'] ?? [],
+            $config['handler_with'] ?? []
+        );
+
+        $handler = $this->prepareHandler(
+            $this->app->make($config['handler'], $with), $config
+        );
+
+        $processors = (new Collection($config['processors'] ?? []))
+            ->map(fn ($processor) => $this->app->make($processor['processor'] ?? $processor, $processor['with'] ?? []))
+            ->toArray();
+
+        return new Monolog(
+            $this->parseChannel($config),
+            [$handler],
+            $processors,
+        );
+    }
+
+    /**
+     * Prepare the handlers for usage by Monolog.
+     *
+     * @param  array  $handlers
+     * @return array
+     */
+    protected function prepareHandlers(array $handlers)
+    {
+        foreach ($handlers as $key => $handler) {
+            $handlers[$key] = $this->prepareHandler($handler);
+        }
+
+        return $handlers;
+    }
+
+    /**
+     * Prepare the handler for usage by Monolog.
+     *
+     * @param  \Monolog\Handler\HandlerInterface  $handler
+     * @param  array  $config
+     * @return \Monolog\Handler\HandlerInterface
+     */
+    protected function prepareHandler(HandlerInterface $handler, array $config = [])
+    {
+        if (isset($config['action_level'])) {
+            $handler = new FingersCrossedHandler(
+                $handler,
+                $this->actionLevel($config),
+                0,
+                true,
+                $config['stop_buffering'] ?? true
+            );
+        }
+
+        if (! $handler instanceof FormattableHandlerInterface) {
+            return $handler;
+        }
+
+        if (! isset($config['formatter'])) {
+            $handler->setFormatter($this->formatter());
+        } elseif ($config['formatter'] !== 'default') {
+            $handler->setFormatter($this->app->make($config['formatter'], $config['formatter_with'] ?? []));
+        }
+
+        return $handler;
+    }
+
+    /**
+     * Get a Monolog formatter instance.
+     *
+     * @return \Monolog\Formatter\FormatterInterface
+     */
+    protected function formatter()
+    {
+        return new LineFormatter(null, $this->dateFormat, true, true, true);
+    }
+
+    /**
+     * Share context across channels and stacks.
+     *
+     * @param  array  $context
+     * @return $this
+     */
+    public function shareContext(array $context)
+    {
+        foreach ($this->channels as $channel) {
+            $channel->withContext($context);
+        }
+
+        $this->sharedContext = array_merge($this->sharedContext, $context);
+
+        return $this;
+    }
+
+    /**
+     * The context shared across channels and stacks.
+     *
+     * @return array
+     */
+    public function sharedContext()
+    {
+        return $this->sharedContext;
+    }
+
+    /**
+     * Flush the log context on all currently resolved channels.
+     *
+     * @param  string[]|null  $keys
+     * @return $this
+     */
+    public function withoutContext(?array $keys = null)
+    {
+        foreach ($this->channels as $channel) {
+            if (method_exists($channel, 'withoutContext')) {
+                $channel->withoutContext($keys);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Flush the shared context.
+     *
+     * @return $this
+     */
+    public function flushSharedContext()
+    {
+        $this->sharedContext = [];
+
+        return $this;
+    }
+
+    /**
+     * Get fallback log channel name.
+     *
+     * @return string
+     */
+    protected function getFallbackChannelName()
+    {
+        return $this->app->bound('env') ? $this->app->environment() : 'production';
+    }
+
+    /**
+     * Get the log connection configuration.
+     *
+     * @param  string  $name
+     * @return array|null
+     */
+    protected function configurationFor($name)
+    {
+        return $this->app['config']["logging.channels.{$name}"];
+    }
+
+    /**
+     * Get the default log driver name.
+     *
+     * @return string|null
+     */
+    public function getDefaultDriver()
+    {
+        return $this->app['config']['logging.default'];
+    }
+
+    /**
+     * Set the default log driver name.
+     *
+     * @param  \UnitEnum|string  $name
+     * @return void
+     */
+    public function setDefaultDriver($name)
+    {
+        $this->app['config']['logging.default'] = enum_value($name);
+    }
+
+    /**
+     * Register a custom driver creator Closure.
+     *
+     * @param  string  $driver
+     * @param  \Closure  $callback
+     *
+     * @param-closure-this  $this  $callback
+     *
+     * @return $this
+     */
+    public function extend($driver, Closure $callback)
+    {
+        try {
+            $callback = $this->bindCallbackToSelf($callback) ?? throw new RuntimeException('Unable to bind custom driver callback');
+        } catch (ReflectionException $e) {
+            throw new RuntimeException('Unable to bind custom driver callback', previous: $e);
+        }
+
+        $this->customCreators[$driver] = $callback;
+
+        return $this;
+    }
+
+    /**
+     * Unset the given channel instance.
+     *
+     * @param  string|null  $driver
+     * @return void
+     */
+    public function forgetChannel($driver = null)
+    {
+        $driver = $this->parseDriver($driver);
+
+        if (isset($this->channels[$driver])) {
+            unset($this->channels[$driver]);
+        }
+    }
+
+    /**
+     * Parse the driver name.
+     *
+     * @param  string|null  $driver
+     * @return string|null
+     */
+    protected function parseDriver($driver)
+    {
+        $driver ??= $this->getDefaultDriver();
+
+        if ($this->app->runningUnitTests()) {
+            $driver ??= 'null';
+        }
+
+        if ($driver === null) {
+            return null;
+        }
+
+        return trim($driver);
+    }
+
+    /**
+     * Get all of the resolved log channels.
+     *
+     * @return array
+     */
+    public function getChannels()
+    {
+        return $this->channels;
+    }
+
+    /**
+     * System is unusable.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function emergency($message, array $context = []): void
+    {
+        $this->driver()->emergency($message, $context);
+    }
+
+    /**
+     * Action must be taken immediately.
+     *
+     * Example: Entire website down, database unavailable, etc. This should
+     * trigger the SMS alerts and wake you up.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function alert($message, array $context = []): void
+    {
+        $this->driver()->alert($message, $context);
+    }
+
+    /**
+     * Critical conditions.
+     *
+     * Example: Application component unavailable, unexpected exception.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function critical($message, array $context = []): void
+    {
+        $this->driver()->critical($message, $context);
+    }
+
+    /**
+     * Runtime errors that do not require immediate action but should typically
+     * be logged and monitored.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function error($message, array $context = []): void
+    {
+        $this->driver()->error($message, $context);
+    }
+
+    /**
+     * Exceptional occurrences that are not errors.
+     *
+     * Example: Use of deprecated APIs, poor use of an API, undesirable things
+     * that are not necessarily wrong.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function warning($message, array $context = []): void
+    {
+        $this->driver()->warning($message, $context);
+    }
+
+    /**
+     * Normal but significant events.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function notice($message, array $context = []): void
+    {
+        $this->driver()->notice($message, $context);
+    }
+
+    /**
+     * Interesting events.
+     *
+     * Example: User logs in, SQL logs.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function info($message, array $context = []): void
+    {
+        $this->driver()->info($message, $context);
+    }
+
+    /**
+     * Detailed debug information.
+     *
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function debug($message, array $context = []): void
+    {
+        $this->driver()->debug($message, $context);
+    }
+
+    /**
+     * Logs with an arbitrary level.
+     *
+     * @param  mixed  $level
+     * @param  string|\Stringable  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function log($level, $message, array $context = []): void
+    {
+        $this->driver()->log($level, $message, $context);
+    }
+
+    /**
+     * Set the application instance used by the manager.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     * @return $this
+     */
+    public function setApplication($app)
+    {
+        $this->app = $app;
+
+        return $this;
+    }
+
+    /**
+     * Dynamically call the default driver instance.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->driver()->$method(...$parameters);
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/LogServiceProvider.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Illuminate\Log;
+
+use Illuminate\Support\ServiceProvider;
+
+class LogServiceProvider extends ServiceProvider
+{
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        $this->app->singleton('log', fn ($app) => new LogManager($app));
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/Logger.php

@@ -0,0 +1,322 @@
+<?php
+
+namespace Illuminate\Log;
+
+use Closure;
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Contracts\Support\Jsonable;
+use Illuminate\Log\Events\MessageLogged;
+use Illuminate\Support\Traits\Conditionable;
+use Psr\Log\LoggerInterface;
+use RuntimeException;
+
+class Logger implements LoggerInterface
+{
+    use Conditionable;
+
+    /**
+     * The underlying logger implementation.
+     *
+     * @var \Psr\Log\LoggerInterface
+     */
+    protected $logger;
+
+    /**
+     * The event dispatcher instance.
+     *
+     * @var \Illuminate\Contracts\Events\Dispatcher|null
+     */
+    protected $dispatcher;
+
+    /**
+     * Any context to be added to logs.
+     *
+     * @var array
+     */
+    protected $context = [];
+
+    /**
+     * Create a new log writer instance.
+     *
+     * @param  \Psr\Log\LoggerInterface  $logger
+     * @param  \Illuminate\Contracts\Events\Dispatcher|null  $dispatcher
+     */
+    public function __construct(LoggerInterface $logger, ?Dispatcher $dispatcher = null)
+    {
+        $this->logger = $logger;
+        $this->dispatcher = $dispatcher;
+    }
+
+    /**
+     * Log an emergency message to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function emergency($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log an alert message to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function alert($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log a critical message to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function critical($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log an error message to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function error($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log a warning message to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function warning($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log a notice to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function notice($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log an informational message to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function info($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log a debug message to the logs.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function debug($message, array $context = []): void
+    {
+        $this->writeLog(__FUNCTION__, $message, $context);
+    }
+
+    /**
+     * Log a message to the logs.
+     *
+     * @param  string  $level
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function log($level, $message, array $context = []): void
+    {
+        $this->writeLog($level, $message, $context);
+    }
+
+    /**
+     * Dynamically pass log calls into the writer.
+     *
+     * @param  string  $level
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    public function write($level, $message, array $context = []): void
+    {
+        $this->writeLog($level, $message, $context);
+    }
+
+    /**
+     * Write a message to the log.
+     *
+     * @param  string  $level
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @param  array  $context
+     * @return void
+     */
+    protected function writeLog($level, $message, $context): void
+    {
+        if (method_exists($this->logger, 'isHandling') && ! $this->logger->isHandling($level)) {
+            return;
+        }
+
+        $this->logger->{$level}(
+            $message = $this->formatMessage($message),
+            $context = array_merge($this->context, $context)
+        );
+
+        $this->fireLogEvent($level, $message, $context);
+    }
+
+    /**
+     * Add context to all future logs.
+     *
+     * @param  array  $context
+     * @return $this
+     */
+    public function withContext(array $context = [])
+    {
+        $this->context = array_merge($this->context, $context);
+
+        return $this;
+    }
+
+    /**
+     * Flush the log context on all currently resolved channels.
+     *
+     * @param  string[]|null  $keys
+     * @return $this
+     */
+    public function withoutContext(?array $keys = null)
+    {
+        if (is_array($keys)) {
+            $this->context = array_diff_key($this->context, array_flip($keys));
+        } else {
+            $this->context = [];
+        }
+
+        return $this;
+    }
+
+    /**
+     * Register a new callback handler for when a log event is triggered.
+     *
+     * @param  \Closure  $callback
+     * @return void
+     *
+     * @throws \RuntimeException
+     */
+    public function listen(Closure $callback)
+    {
+        if (! isset($this->dispatcher)) {
+            throw new RuntimeException('Events dispatcher has not been set.');
+        }
+
+        $this->dispatcher->listen(MessageLogged::class, $callback);
+    }
+
+    /**
+     * Fires a log event.
+     *
+     * @param  string  $level
+     * @param  string  $message
+     * @param  array  $context
+     * @return void
+     */
+    protected function fireLogEvent($level, $message, array $context = [])
+    {
+        // Avoid dispatching the event multiple times if our logger instance is the LogManager...
+        if ($this->logger instanceof LogManager &&
+            $this->logger->getEventDispatcher() !== null) {
+            return;
+        }
+
+        // If the event dispatcher is set, we will pass along the parameters to the
+        // log listeners. These are useful for building profilers or other tools
+        // that aggregate all of the log messages for a given "request" cycle.
+        $this->dispatcher?->dispatch(new MessageLogged($level, $message, $context));
+    }
+
+    /**
+     * Format the parameters for the logger.
+     *
+     * @param  \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string  $message
+     * @return string
+     */
+    protected function formatMessage($message)
+    {
+        return match (true) {
+            is_array($message) => var_export($message, true),
+            $message instanceof Jsonable => $message->toJson(),
+            $message instanceof Arrayable => var_export($message->toArray(), true),
+            default => (string) $message,
+        };
+    }
+
+    /**
+     * Get the underlying logger implementation.
+     *
+     * @return \Psr\Log\LoggerInterface
+     */
+    public function getLogger()
+    {
+        return $this->logger;
+    }
+
+    /**
+     * Get the event dispatcher instance.
+     *
+     * @return \Illuminate\Contracts\Events\Dispatcher|null
+     */
+    public function getEventDispatcher()
+    {
+        return $this->dispatcher;
+    }
+
+    /**
+     * Set the event dispatcher instance.
+     *
+     * @param  \Illuminate\Contracts\Events\Dispatcher  $dispatcher
+     * @return void
+     */
+    public function setEventDispatcher(Dispatcher $dispatcher)
+    {
+        $this->dispatcher = $dispatcher;
+    }
+
+    /**
+     * Dynamically proxy method calls to the underlying logger.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->logger->{$method}(...$parameters);
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/ParsesLogConfiguration.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace Illuminate\Log;
+
+use InvalidArgumentException;
+use Monolog\Level;
+
+trait ParsesLogConfiguration
+{
+    /**
+     * The Log levels.
+     *
+     * @var array
+     */
+    protected $levels = [
+        'debug' => Level::Debug,
+        'info' => Level::Info,
+        'notice' => Level::Notice,
+        'warning' => Level::Warning,
+        'error' => Level::Error,
+        'critical' => Level::Critical,
+        'alert' => Level::Alert,
+        'emergency' => Level::Emergency,
+    ];
+
+    /**
+     * Get fallback log channel name.
+     *
+     * @return string
+     */
+    abstract protected function getFallbackChannelName();
+
+    /**
+     * Parse the string level into a Monolog constant.
+     *
+     * @param  array  $config
+     * @return int
+     *
+     * @throws \InvalidArgumentException
+     */
+    protected function level(array $config)
+    {
+        $level = $config['level'] ?? 'debug';
+
+        if (isset($this->levels[$level])) {
+            return $this->levels[$level];
+        }
+
+        throw new InvalidArgumentException('Invalid log level.');
+    }
+
+    /**
+     * Parse the action level from the given configuration.
+     *
+     * @param  array  $config
+     * @return int
+     *
+     * @throws \InvalidArgumentException
+     */
+    protected function actionLevel(array $config)
+    {
+        $level = $config['action_level'] ?? 'debug';
+
+        if (isset($this->levels[$level])) {
+            return $this->levels[$level];
+        }
+
+        throw new InvalidArgumentException('Invalid log action level.');
+    }
+
+    /**
+     * Extract the log channel from the given configuration.
+     *
+     * @param  array  $config
+     * @return string
+     */
+    protected function parseChannel(array $config)
+    {
+        return $config['name'] ?? $this->getFallbackChannelName();
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/composer.json

@@ -0,0 +1,40 @@
+{
+    "name": "illuminate/log",
+    "description": "The Illuminate Log package.",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylor@laravel.com"
+        }
+    ],
+    "homepage": "https://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "require": {
+        "php": "^8.3",
+        "illuminate/contracts": "^13.0",
+        "illuminate/support": "^13.0",
+        "monolog/monolog": "^3.0",
+        "psr/log": "^1.0 || ^2.0 || ^3.0"
+    },
+    "provide": {
+        "psr/log-implementation": "1.0 || 2.0 || 3.0"
+    },
+    "minimum-stability": "dev",
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Log\\": ""
+        }
+    },
+    "config": {
+        "sort-packages": true
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "13.0.x-dev"
+        }
+    }
+}

vendor/laravel/framework/src/Illuminate/Log/functions.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Illuminate\Log;
+
+use Psr\Log\LoggerInterface;
+
+if (! function_exists('Illuminate\Log\log')) {
+    /**
+     * Log a debug message to the logs.
+     *
+     * @param  string|null  $message
+     * @param  array  $context
+     * @return ($message is null ? \Psr\Log\LoggerInterface: null)
+     */
+    function log($message = null, array $context = []): ?LoggerInterface
+    {
+        return logger($message, $context);
+    }
+}