🎉

vendor/spatie/backtrace/src/Arguments/ArgumentReducers.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments;
+
+use Spatie\Backtrace\Arguments\Reducers\ArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\ArrayArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\BaseTypeArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\ClosureArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\DateTimeArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\DateTimeZoneArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\EnumArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\MinimalArrayArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\SensitiveParameterArrayReducer;
+use Spatie\Backtrace\Arguments\Reducers\StdClassArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\StringableArgumentReducer;
+use Spatie\Backtrace\Arguments\Reducers\SymphonyRequestArgumentReducer;
+
+class ArgumentReducers
+{
+    /** @var array<int, ArgumentReducer> */
+    public $argumentReducers = [];
+
+    /**
+     * @param array<ArgumentReducer|class-string<ArgumentReducer>> $argumentReducers
+     */
+    public static function create(array $argumentReducers): self
+    {
+        return new self(array_map(
+            function ($argumentReducer) {
+                /** @var $argumentReducer ArgumentReducer|class-string<ArgumentReducer> */
+                return $argumentReducer instanceof ArgumentReducer ? $argumentReducer : new $argumentReducer();
+            },
+            $argumentReducers
+        ));
+    }
+
+    public static function default(array $extra = []): self
+    {
+        return new self(static::defaultReducers($extra));
+    }
+
+    public static function minimal(array $extra = []): self
+    {
+        return new self(static::minimalReducers($extra));
+    }
+
+    /**
+     * @param array<int, ArgumentReducer> $argumentReducers
+     */
+    protected function __construct(array $argumentReducers)
+    {
+        $this->argumentReducers = $argumentReducers;
+    }
+
+    protected static function defaultReducers(array $extra = []): array
+    {
+        return array_merge($extra, [
+            new BaseTypeArgumentReducer(),
+            new ArrayArgumentReducer(),
+            new StdClassArgumentReducer(),
+            new EnumArgumentReducer(),
+            new ClosureArgumentReducer(),
+            new SensitiveParameterArrayReducer(),
+            new DateTimeArgumentReducer(),
+            new DateTimeZoneArgumentReducer(),
+            new SymphonyRequestArgumentReducer(),
+            new StringableArgumentReducer(),
+        ]);
+    }
+
+    protected static function minimalReducers(array $extra = []): array
+    {
+        return array_merge($extra, [
+            new BaseTypeArgumentReducer(),
+            new MinimalArrayArgumentReducer(),
+            new EnumArgumentReducer(),
+            new ClosureArgumentReducer(),
+            new SensitiveParameterArrayReducer(),
+        ]);
+    }
+}

vendor/spatie/backtrace/src/Arguments/ProvidedArgument.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments;
+
+use ReflectionParameter;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\TruncatedReducedArgument;
+
+class ProvidedArgument
+{
+    /** @var string */
+    public $name;
+
+    /** @var bool */
+    public $passedByReference = false;
+
+    /** @var bool */
+    public $isVariadic = false;
+
+    /** @var bool */
+    public $hasDefaultValue = false;
+
+    /** @var mixed */
+    public $defaultValue = null;
+
+    /** @var bool */
+    public $defaultValueUsed = false;
+
+    /** @var bool */
+    public $truncated = false;
+
+    /** @var mixed */
+    public $reducedValue = null;
+
+    /** @var string|null */
+    public $originalType = null;
+
+    public static function fromReflectionParameter(ReflectionParameter $parameter): self
+    {
+        return new self(
+            $parameter->getName(),
+            $parameter->isPassedByReference(),
+            $parameter->isVariadic(),
+            $parameter->isDefaultValueAvailable(),
+            $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null,
+        );
+    }
+
+    public static function fromNonReflectableParameter(
+        int $index
+    ): self {
+        return new self(
+            "arg{$index}",
+            false,
+        );
+    }
+
+    public function __construct(
+        string $name,
+        bool $passedByReference = false,
+        bool $isVariadic = false,
+        bool $hasDefaultValue = false,
+        $defaultValue = null,
+        bool $defaultValueUsed = false,
+        bool $truncated = false,
+        $reducedValue = null,
+        ?string $originalType = null
+    ) {
+        $this->originalType = $originalType;
+        $this->reducedValue = $reducedValue;
+        $this->truncated = $truncated;
+        $this->defaultValueUsed = $defaultValueUsed;
+        $this->defaultValue = $defaultValue;
+        $this->hasDefaultValue = $hasDefaultValue;
+        $this->isVariadic = $isVariadic;
+        $this->passedByReference = $passedByReference;
+        $this->name = $name;
+
+        if ($this->isVariadic) {
+            $this->defaultValue = [];
+        }
+    }
+
+    public function setReducedArgument(
+        ReducedArgument $reducedArgument
+    ): self {
+        $this->reducedValue = $reducedArgument->value;
+        $this->originalType = $reducedArgument->originalType;
+
+        if ($reducedArgument instanceof TruncatedReducedArgument) {
+            $this->truncated = true;
+        }
+
+        return $this;
+    }
+
+    public function defaultValueUsed(): self
+    {
+        $this->defaultValueUsed = true;
+        $this->originalType = get_debug_type($this->defaultValue);
+
+        return $this;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'name' => $this->name,
+            'value' => $this->defaultValueUsed
+                ? $this->defaultValue
+                : $this->reducedValue,
+            'original_type' => $this->originalType,
+            'passed_by_reference' => $this->passedByReference,
+            'is_variadic' => $this->isVariadic,
+            'truncated' => $this->truncated,
+        ];
+    }
+}

vendor/spatie/backtrace/src/Arguments/ReduceArgumentPayloadAction.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+
+class ReduceArgumentPayloadAction
+{
+    /** @var \Spatie\Backtrace\Arguments\ArgumentReducers */
+    protected $argumentReducers;
+
+    public function __construct(
+        ArgumentReducers $argumentReducers
+    ) {
+        $this->argumentReducers = $argumentReducers;
+    }
+
+    public function reduce($argument, bool $includeObjectType = false): ReducedArgument
+    {
+        foreach ($this->argumentReducers->argumentReducers as $reducer) {
+            $reduced = $reducer->execute($argument);
+
+            if ($reduced instanceof ReducedArgument) {
+                return $reduced;
+            }
+        }
+
+        if (gettype($argument) === 'object' && $includeObjectType) {
+            return new ReducedArgument(
+                'object ('.get_class($argument).')',
+                get_debug_type($argument),
+            );
+        }
+
+        if (gettype($argument) === 'object') {
+            return new ReducedArgument('object', get_debug_type($argument), );
+        }
+
+        return new ReducedArgument(
+            $argument,
+            get_debug_type($argument),
+        );
+    }
+}

vendor/spatie/backtrace/src/Arguments/ReduceArgumentsAction.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments;
+
+use ReflectionException;
+use ReflectionFunction;
+use ReflectionMethod;
+use ReflectionParameter;
+use Spatie\Backtrace\Arguments\ReducedArgument\VariadicReducedArgument;
+use Throwable;
+
+class ReduceArgumentsAction
+{
+    /** @var ArgumentReducers */
+    protected $argumentReducers;
+
+    /** @var ReduceArgumentPayloadAction */
+    protected $reduceArgumentPayloadAction;
+
+    public function __construct(
+        ArgumentReducers $argumentReducers
+    ) {
+        $this->argumentReducers = $argumentReducers;
+        $this->reduceArgumentPayloadAction = new ReduceArgumentPayloadAction($argumentReducers);
+    }
+
+    public function execute(
+        ?string $class,
+        ?string $method,
+        ?array $frameArguments
+    ): ?array {
+        try {
+            if ($frameArguments === null) {
+                return null;
+            }
+
+            $parameters = $this->getParameters($class, $method);
+
+            if ($parameters === null) {
+                $arguments = [];
+
+                foreach ($frameArguments as $index => $argument) {
+                    $arguments[$index] = ProvidedArgument::fromNonReflectableParameter($index)
+                        ->setReducedArgument($this->reduceArgumentPayloadAction->reduce($argument))
+                        ->toArray();
+                }
+
+                return $arguments;
+            }
+
+            $arguments = array_map(
+                function ($argument) {
+                    return $this->reduceArgumentPayloadAction->reduce($argument);
+                },
+                $frameArguments,
+            );
+
+            $argumentsCount = count($arguments);
+            $hasVariadicParameter = false;
+
+            foreach ($parameters as $index => $parameter) {
+                if ($index + 1 > $argumentsCount) {
+                    $parameter->defaultValueUsed();
+                } elseif ($parameter->isVariadic) {
+                    $parameter->setReducedArgument(new VariadicReducedArgument(array_slice($arguments, $index)));
+
+                    $hasVariadicParameter = true;
+                } else {
+                    $parameter->setReducedArgument($arguments[$index]);
+                }
+
+                $parameters[$index] = $parameter->toArray();
+            }
+
+            if ($this->moreArgumentsProvidedThanParameters($arguments, $parameters, $hasVariadicParameter)) {
+                for ($i = count($parameters); $i < count($arguments); $i++) {
+                    $parameters[$i] = ProvidedArgument::fromNonReflectableParameter(count($parameters))
+                        ->setReducedArgument($arguments[$i])
+                        ->toArray();
+                }
+            }
+
+            return $parameters;
+        } catch (Throwable $e) {
+            return null;
+        }
+    }
+
+    /** @return null|Array<\Spatie\Backtrace\Arguments\ProvidedArgument> */
+    protected function getParameters(
+        ?string $class,
+        ?string $method
+    ): ?array {
+        try {
+            $reflection = $class !== null
+                ? new ReflectionMethod($class, $method)
+                : new ReflectionFunction($method);
+        } catch (ReflectionException $e) {
+            return null;
+        }
+
+        return array_map(
+            function (ReflectionParameter $reflectionParameter) {
+                return ProvidedArgument::fromReflectionParameter($reflectionParameter);
+            },
+            $reflection->getParameters(),
+        );
+    }
+
+    protected function moreArgumentsProvidedThanParameters(
+        array $arguments,
+        array $parameters,
+        bool $hasVariadicParameter
+    ): bool {
+        return count($arguments) > count($parameters) && ! $hasVariadicParameter;
+    }
+}

vendor/spatie/backtrace/src/Arguments/ReducedArgument/ReducedArgument.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\ReducedArgument;
+
+class ReducedArgument implements ReducedArgumentContract
+{
+    /** @var mixed */
+    public $value;
+
+    /** @var string */
+    public $originalType;
+
+    /**
+     * @param mixed $value
+     */
+    public function __construct(
+        $value,
+        string $originalType
+    ) {
+        $this->originalType = $originalType;
+        $this->value = $value;
+    }
+}

vendor/spatie/backtrace/src/Arguments/ReducedArgument/ReducedArgumentContract.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\ReducedArgument;
+
+interface ReducedArgumentContract
+{
+
+}

vendor/spatie/backtrace/src/Arguments/ReducedArgument/TruncatedReducedArgument.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\ReducedArgument;
+
+class TruncatedReducedArgument extends ReducedArgument
+{
+
+}

vendor/spatie/backtrace/src/Arguments/ReducedArgument/UnReducedArgument.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\ReducedArgument;
+
+class UnReducedArgument implements ReducedArgumentContract
+{
+    /** @var self|null */
+    private static $instance = null;
+
+    private function __construct()
+    {
+    }
+
+    public static function create(): self
+    {
+        if (self::$instance !== null) {
+            return self::$instance;
+        }
+
+        return self::$instance = new self();
+    }
+}

vendor/spatie/backtrace/src/Arguments/ReducedArgument/VariadicReducedArgument.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\ReducedArgument;
+
+use Exception;
+
+class VariadicReducedArgument extends ReducedArgument
+{
+    public function __construct(array $value)
+    {
+        foreach ($value as $key => $item) {
+            if (! $item instanceof ReducedArgument) {
+                throw new Exception('VariadicReducedArgument must be an array of ReducedArgument');
+            }
+
+            $value[$key] = $item->value;
+        }
+
+        parent::__construct($value, 'array');
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/ArgumentReducer.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+
+interface ArgumentReducer
+{
+    /**
+     * @param mixed $argument
+     */
+    public function execute($argument): ReducedArgumentContract;
+}

vendor/spatie/backtrace/src/Arguments/Reducers/ArrayArgumentReducer.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ArgumentReducers;
+use Spatie\Backtrace\Arguments\ReduceArgumentPayloadAction;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\TruncatedReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+
+class ArrayArgumentReducer implements ReducedArgumentContract
+{
+    /** @var int */
+    protected $maxArraySize = 25;
+
+    /** @var \Spatie\Backtrace\Arguments\ReduceArgumentPayloadAction */
+    protected $reduceArgumentPayloadAction;
+
+    public function __construct()
+    {
+        $this->reduceArgumentPayloadAction = new ReduceArgumentPayloadAction(ArgumentReducers::minimal());
+    }
+
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! is_array($argument)) {
+            return UnReducedArgument::create();
+        }
+
+        return $this->reduceArgument($argument, 'array');
+    }
+
+    protected function reduceArgument(array $argument, string $originalType): ReducedArgumentContract
+    {
+        foreach ($argument as $key => $value) {
+            $argument[$key] = $this->reduceArgumentPayloadAction->reduce(
+                $value,
+                true
+            )->value;
+        }
+
+        if (count($argument) > $this->maxArraySize) {
+            return new TruncatedReducedArgument(
+                array_slice($argument, 0, $this->maxArraySize),
+                'array'
+            );
+        }
+
+        return new ReducedArgument($argument, $originalType);
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/BaseTypeArgumentReducer.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+
+class BaseTypeArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (is_int($argument)
+            || is_float($argument)
+            || is_bool($argument)
+            || is_string($argument)
+            || $argument === null
+        ) {
+            return new ReducedArgument($argument, get_debug_type($argument));
+        }
+
+        return UnReducedArgument::create();
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/ClosureArgumentReducer.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Closure;
+use ReflectionFunction;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+
+class ClosureArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! $argument instanceof Closure) {
+            return UnReducedArgument::create();
+        }
+
+        $reflection = new ReflectionFunction($argument);
+
+        if ($reflection->getFileName() && $reflection->getStartLine() && $reflection->getEndLine()) {
+            return new ReducedArgument(
+                "{$reflection->getFileName()}:{$reflection->getStartLine()}-{$reflection->getEndLine()}",
+                'Closure'
+            );
+        }
+
+        return new ReducedArgument("{$reflection->getFileName()}", 'Closure');
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/DateTimeArgumentReducer.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use DateTimeInterface;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+
+class DateTimeArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! $argument instanceof DateTimeInterface) {
+            return UnReducedArgument::create();
+        }
+
+        return new ReducedArgument(
+            $argument->format('d M Y H:i:s e'),
+            get_class($argument),
+        );
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/DateTimeZoneArgumentReducer.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use DateTimeZone;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+
+class DateTimeZoneArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! $argument instanceof DateTimeZone) {
+            return UnReducedArgument::create();
+        }
+
+        return new ReducedArgument(
+            $argument->getName(),
+            get_class($argument),
+        );
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/EnumArgumentReducer.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+use UnitEnum;
+
+class EnumArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! $argument instanceof UnitEnum) {
+            return UnReducedArgument::create();
+        }
+
+        return new ReducedArgument(
+            get_class($argument).'::'.$argument->name,
+            get_class($argument),
+        );
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/MinimalArrayArgumentReducer.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+
+class MinimalArrayArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if(! is_array($argument)) {
+            return UnReducedArgument::create();
+        }
+
+        return new ReducedArgument(
+            'array (size='.count($argument).')',
+            'array'
+        );
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/SensitiveParameterArrayReducer.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use SensitiveParameterValue;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+
+class SensitiveParameterArrayReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! $argument instanceof SensitiveParameterValue) {
+            return UnReducedArgument::create();
+        }
+
+        return new ReducedArgument(
+            'SensitiveParameterValue('.get_debug_type($argument->getValue()).')',
+            get_class($argument)
+        );
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/StdClassArgumentReducer.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+use stdClass;
+
+class StdClassArgumentReducer extends ArrayArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! $argument instanceof stdClass) {
+            return UnReducedArgument::create();
+        }
+
+        return parent::reduceArgument((array) $argument, stdClass::class);
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/StringableArgumentReducer.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+use Stringable;
+
+class StringableArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if (! $argument instanceof Stringable) {
+            return UnReducedArgument::create();
+        }
+
+        return new ReducedArgument(
+            (string) $argument,
+            get_class($argument),
+        );
+    }
+}

vendor/spatie/backtrace/src/Arguments/Reducers/SymphonyRequestArgumentReducer.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Spatie\Backtrace\Arguments\Reducers;
+
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgument;
+use Spatie\Backtrace\Arguments\ReducedArgument\ReducedArgumentContract;
+use Spatie\Backtrace\Arguments\ReducedArgument\UnReducedArgument;
+use Symfony\Component\HttpFoundation\Request;
+
+class SymphonyRequestArgumentReducer implements ArgumentReducer
+{
+    public function execute($argument): ReducedArgumentContract
+    {
+        if(! $argument instanceof Request) {
+            return UnReducedArgument::create();
+        }
+
+        return new ReducedArgument(
+            "{$argument->getMethod()} {$argument->getUri()}",
+            get_class($argument),
+        );
+    }
+}