<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: TraceMiddleware.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php
namespace Aws;

use Aws\Api\Service;
use Aws\Exception\AwsException;
use GuzzleHttp\Promise\RejectedPromise;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;
use RecursiveArrayIterator;
use RecursiveIteratorIterator;

/**
 * Traces state changes between middlewares.
 */
class TraceMiddleware
{
    private $prevOutput;
    private $prevInput;
    private $config;

    /** @var Service */
    private $service;

    private static $authHeaders = [
        'X-Amz-Security-Token' =&gt; '[TOKEN]',
    ];

    private static $authStrings = [
        // S3Signature
        '/AWSAccessKeyId=[A-Z0-9]{20}&amp;/i' =&gt; 'AWSAccessKeyId=[KEY]&amp;',
        // SignatureV4 Signature and S3Signature
        '/Signature=.+/i' =&gt; 'Signature=[SIGNATURE]',
        // SignatureV4 access key ID
        '/Credential=[A-Z0-9]{20}\//i' =&gt; 'Credential=[KEY]/',
        // S3 signatures
        '/AWS [A-Z0-9]{20}:.+/' =&gt; 'AWS AKI[KEY]:[SIGNATURE]',
        // STS Presigned URLs
        '/X-Amz-Security-Token=[^&amp;]+/i' =&gt; 'X-Amz-Security-Token=[TOKEN]',
        // Crypto *Stream Keys
        '/\[&quot;key.{27,36}Stream.{9}\]=&gt;\s+.{7}\d{2}\) &quot;\X{16,64}&quot;/U' =&gt; '[&quot;key&quot;:[CONTENT KEY]]',
    ];

    /**
     * Configuration array can contain the following key value pairs.
     *
     * - logfn: (callable) Function that is invoked with log messages. By
     *   default, PHP's &quot;echo&quot; function will be utilized.
     * - stream_size: (int) When the size of a stream is greater than this
     *   number, the stream data will not be logged. Set to &quot;0&quot; to not log any
     *   stream data.
     * - scrub_auth: (bool) Set to false to disable the scrubbing of auth data
     *   from the logged messages.
     * - http: (bool) Set to false to disable the &quot;debug&quot; feature of lower
     *   level HTTP adapters (e.g., verbose curl output).
     * - auth_strings: (array) A mapping of authentication string regular
     *   expressions to scrubbed strings. These mappings are passed directly to
     *   preg_replace (e.g., preg_replace($key, $value, $debugOutput) if
     *   &quot;scrub_auth&quot; is set to true.
     * - auth_headers: (array) A mapping of header names known to contain
     *   sensitive data to what the scrubbed value should be. The value of any
     *   headers contained in this array will be replaced with the if
     *   &quot;scrub_auth&quot; is set to true.
     */
    public function __construct(array $config = [], Service $service = null)
    {
        $this-&gt;config = $config + [
            'logfn'        =&gt; function ($value) { echo $value; },
            'stream_size'  =&gt; 524288,
            'scrub_auth'   =&gt; true,
            'http'         =&gt; true,
            'auth_strings' =&gt; [],
            'auth_headers' =&gt; [],
        ];

        $this-&gt;config['auth_strings'] += self::$authStrings;
        $this-&gt;config['auth_headers'] += self::$authHeaders;
        $this-&gt;service = $service;
    }

    public function __invoke($step, $name)
    {
        $this-&gt;prevOutput = $this-&gt;prevInput = [];

        return function (callable $next) use ($step, $name) {
            return function (
                CommandInterface $command,
                RequestInterface $request = null
            ) use ($next, $step, $name) {
                $this-&gt;createHttpDebug($command);
                $start = microtime(true);
                $this-&gt;stepInput([
                    'step'    =&gt; $step,
                    'name'    =&gt; $name,
                    'request' =&gt; $this-&gt;requestArray($request),
                    'command' =&gt; $this-&gt;commandArray($command)
                ]);

                return $next($command, $request)-&gt;then(
                    function ($value) use ($step, $name, $command, $start) {
                        $this-&gt;flushHttpDebug($command);
                        $this-&gt;stepOutput($start, [
                            'step'   =&gt; $step,
                            'name'   =&gt; $name,
                            'result' =&gt; $this-&gt;resultArray($value),
                            'error'  =&gt; null
                        ]);
                        return $value;
                    },
                    function ($reason) use ($step, $name, $start, $command) {
                        $this-&gt;flushHttpDebug($command);
                        $this-&gt;stepOutput($start, [
                            'step'   =&gt; $step,
                            'name'   =&gt; $name,
                            'result' =&gt; null,
                            'error'  =&gt; $this-&gt;exceptionArray($reason)
                        ]);
                        return new RejectedPromise($reason);
                    }
                );
            };
        };
    }

    private function stepInput($entry)
    {
        static $keys = ['command', 'request'];
        $this-&gt;compareStep($this-&gt;prevInput, $entry, '-&gt; Entering', $keys);
        $this-&gt;write(&quot;\n&quot;);
        $this-&gt;prevInput = $entry;
    }

    private function stepOutput($start, $entry)
    {
        static $keys = ['result', 'error'];
        $this-&gt;compareStep($this-&gt;prevOutput, $entry, '&lt;- Leaving', $keys);
        $totalTime = microtime(true) - $start;
        $this-&gt;write(&quot;  Inclusive step time: &quot; . $totalTime . &quot;\n\n&quot;);
        $this-&gt;prevOutput = $entry;
    }

    private function compareStep(array $a, array $b, $title, array $keys)
    {
        $changes = [];
        foreach ($keys as $key) {
            $av = isset($a[$key]) ? $a[$key] : null;
            $bv = isset($b[$key]) ? $b[$key] : null;
            $this-&gt;compareArray($av, $bv, $key, $changes);
        }
        $str = &quot;\n{$title} step {$b['step']}, name '{$b['name']}'&quot;;
        $str .= &quot;\n&quot; . str_repeat('-', strlen($str) - 1) . &quot;\n\n  &quot;;
        $str .= $changes
            ? implode(&quot;\n  &quot;, str_replace(&quot;\n&quot;, &quot;\n  &quot;, $changes))
            : 'no changes';
        $this-&gt;write($str . &quot;\n&quot;);
    }

    private function commandArray(CommandInterface $cmd)
    {
        return [
            'instance' =&gt; spl_object_hash($cmd),
            'name'     =&gt; $cmd-&gt;getName(),
            'params'   =&gt; $this-&gt;getRedactedArray($cmd)
        ];
    }

    private function requestArray(RequestInterface $request = null)
    {
        return !$request ? [] : array_filter([
            'instance' =&gt; spl_object_hash($request),
            'method'   =&gt; $request-&gt;getMethod(),
            'headers'  =&gt; $this-&gt;redactHeaders($request-&gt;getHeaders()),
            'body'     =&gt; $this-&gt;streamStr($request-&gt;getBody()),
            'scheme'   =&gt; $request-&gt;getUri()-&gt;getScheme(),
            'port'     =&gt; $request-&gt;getUri()-&gt;getPort(),
            'path'     =&gt; $request-&gt;getUri()-&gt;getPath(),
            'query'    =&gt; $request-&gt;getUri()-&gt;getQuery(),
        ]);
    }

    private function responseArray(ResponseInterface $response = null)
    {
        return !$response ? [] : [
            'instance'   =&gt; spl_object_hash($response),
            'statusCode' =&gt; $response-&gt;getStatusCode(),
            'headers'    =&gt; $this-&gt;redactHeaders($response-&gt;getHeaders()),
            'body'       =&gt; $this-&gt;streamStr($response-&gt;getBody())
        ];
    }

    private function resultArray($value)
    {
        return $value instanceof ResultInterface
            ? [
                'instance' =&gt; spl_object_hash($value),
                'data'     =&gt; $value-&gt;toArray()
            ] : $value;
    }

    private function exceptionArray($e)
    {
        if (!($e instanceof \Exception)) {
            return $e;
        }

        $result = [
            'instance'   =&gt; spl_object_hash($e),
            'class'      =&gt; get_class($e),
            'message'    =&gt; $e-&gt;getMessage(),
            'file'       =&gt; $e-&gt;getFile(),
            'line'       =&gt; $e-&gt;getLine(),
            'trace'      =&gt; $e-&gt;getTraceAsString(),
        ];

        if ($e instanceof AwsException) {
            $result += [
                'type'       =&gt; $e-&gt;getAwsErrorType(),
                'code'       =&gt; $e-&gt;getAwsErrorCode(),
                'requestId'  =&gt; $e-&gt;getAwsRequestId(),
                'statusCode' =&gt; $e-&gt;getStatusCode(),
                'result'     =&gt; $this-&gt;resultArray($e-&gt;getResult()),
                'request'    =&gt; $this-&gt;requestArray($e-&gt;getRequest()),
                'response'   =&gt; $this-&gt;responseArray($e-&gt;getResponse()),
            ];
        }

        return $result;
    }

    private function compareArray($a, $b, $path, array &amp;$diff)
    {
        if ($a === $b) {
            return;
        }

        if (is_array($a)) {
            $b = (array) $b;
            $keys = array_unique(array_merge(array_keys($a), array_keys($b)));
            foreach ($keys as $k) {
                if (!array_key_exists($k, $a)) {
                    $this-&gt;compareArray(null, $b[$k], &quot;{$path}.{$k}&quot;, $diff);
                } elseif (!array_key_exists($k, $b)) {
                    $this-&gt;compareArray($a[$k], null, &quot;{$path}.{$k}&quot;, $diff);
                } else {
                    $this-&gt;compareArray($a[$k], $b[$k], &quot;{$path}.{$k}&quot;, $diff);
                }
            }
        } elseif ($a !== null &amp;&amp; $b === null) {
            $diff[] = &quot;{$path} was unset&quot;;
        } elseif ($a === null &amp;&amp; $b !== null) {
            $diff[] = sprintf(&quot;%s was set to %s&quot;, $path, $this-&gt;str($b));
        } else {
            $diff[] = sprintf(&quot;%s changed from %s to %s&quot;, $path, $this-&gt;str($a), $this-&gt;str($b));
        }
    }

    private function str($value)
    {
        if (is_scalar($value)) {
            return (string) $value;
        }

        if ($value instanceof \Exception) {
            $value = $this-&gt;exceptionArray($value);
        }

        ob_start();
        var_dump($value);
        return ob_get_clean();
    }

    private function streamStr(StreamInterface $body)
    {
        return $body-&gt;getSize() &lt; $this-&gt;config['stream_size']
            ? (string) $body
            : 'stream(size=' . $body-&gt;getSize() . ')';
    }

    private function createHttpDebug(CommandInterface $command)
    {
        if ($this-&gt;config['http'] &amp;&amp; !isset($command['@http']['debug'])) {
            $command['@http']['debug'] = fopen('php://temp', 'w+');
        }
    }

    private function flushHttpDebug(CommandInterface $command)
    {
        if ($res = $command['@http']['debug']) {
            rewind($res);
            $this-&gt;write(stream_get_contents($res));
            fclose($res);
            $command['@http']['debug'] = null;
        }
    }

    private function write($value)
    {
        if ($this-&gt;config['scrub_auth']) {
            foreach ($this-&gt;config['auth_strings'] as $pattern =&gt; $replacement) {
                $value = preg_replace_callback(
                    $pattern,
                    function ($matches) use ($replacement) {
                        return $replacement;
                    },
                    $value
                );
            }
        }

        call_user_func($this-&gt;config['logfn'], $value);
    }

    private function redactHeaders(array $headers)
    {
        if ($this-&gt;config['scrub_auth']) {
            $headers = $this-&gt;config['auth_headers'] + $headers;
        }

        return $headers;
    }

    /**
     * @param CommandInterface $cmd
     * @return array
     */
    private function getRedactedArray(CommandInterface $cmd)
    {
        if (!isset($this-&gt;service[&quot;shapes&quot;])) {
            return $cmd-&gt;toArray();
        }
        $shapes = $this-&gt;service[&quot;shapes&quot;];
        $cmdArray = $cmd-&gt;toArray();
        $iterator = new RecursiveIteratorIterator(
            new RecursiveArrayIterator($cmdArray),
            RecursiveIteratorIterator::SELF_FIRST
        );
        foreach ($iterator as $parameter =&gt; $value) {
           if (isset($shapes[$parameter]['sensitive']) &amp;&amp;
               $shapes[$parameter]['sensitive'] === true
           ) {
               $redactedValue = is_string($value) ? &quot;[{$parameter}]&quot; : [&quot;[{$parameter}]&quot;];
               $currentDepth = $iterator-&gt;getDepth();
               for ($subDepth = $currentDepth; $subDepth &gt;= 0; $subDepth--) {
                   $subIterator = $iterator-&gt;getSubIterator($subDepth);
                   $subIterator-&gt;offsetSet(
                       $subIterator-&gt;key(),
                       ($subDepth === $currentDepth
                           ? $redactedValue
                           : $iterator-&gt;getSubIterator(($subDepth+1))-&gt;getArrayCopy()
                       )
                   );
               }
           }
        }
        return $iterator-&gt;getArrayCopy();
    }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Fvendor%2Faws%2Faws-sdk-php%2Fsrc'>🔙 Back</a>