Proyectos de Subversion Moodle

<?php

namespace Aws\ClientSideMonitoring;

use Aws\CommandInterface;

use Aws\Credentials\CredentialsInterface;

use Aws\Exception\AwsException;

use Aws\ResponseContainerInterface;

use Aws\ResultInterface;

use Psr\Http\Message\RequestInterface;

use Psr\Http\Message\ResponseInterface;

/**

 * @internal

 */

class ApiCallAttemptMonitoringMiddleware extends AbstractMonitoringMiddleware

{

    /**

     * Standard middleware wrapper function with CSM options passed in.

     *

     * @param callable $credentialProvider

     * @param mixed  $options

     * @param string $region

     * @param string $service

     * @return callable

     */

    public static function wrap(

        callable $credentialProvider,

        $options,

        $region,

        $service

    ) {

        return function (callable $handler) use (

            $credentialProvider,

            $options,

            $region,

            $service

        ) {

            return new static(

                $handler,

                $credentialProvider,

                $options,

                $region,

                $service

            );

        };

    }

    /**

     * {@inheritdoc}

     */

    public static function getRequestData(RequestInterface $request)

    {

        return [

            'Fqdn' => $request->getUri()->getHost(),

        ];

    }

    /**

     * {@inheritdoc}

     */

    public static function getResponseData($klass)

    {

        if ($klass instanceof ResultInterface) {

            return [

                'AttemptLatency' => self::getResultAttemptLatency($klass),

                'DestinationIp' => self::getResultDestinationIp($klass),

                'DnsLatency' => self::getResultDnsLatency($klass),

                'HttpStatusCode' => self::getResultHttpStatusCode($klass),

                'XAmzId2' => self::getResultHeader($klass, 'x-amz-id-2'),

                'XAmzRequestId' => self::getResultHeader($klass, 'x-amz-request-id'),

                'XAmznRequestId' => self::getResultHeader($klass, 'x-amzn-RequestId'),

            ];

        }

        if ($klass instanceof AwsException) {

            return [

                'AttemptLatency' => self::getAwsExceptionAttemptLatency($klass),

                'AwsException' => substr(

                    self::getAwsExceptionErrorCode($klass),

                    0,

                    128

                ),

                'AwsExceptionMessage' => substr(

                    self::getAwsExceptionMessage($klass),

                    0,

                    512

                ),

                'DestinationIp' => self::getAwsExceptionDestinationIp($klass),

                'DnsLatency' => self::getAwsExceptionDnsLatency($klass),

                'HttpStatusCode' => self::getAwsExceptionHttpStatusCode($klass),

                'XAmzId2' => self::getAwsExceptionHeader($klass, 'x-amz-id-2'),

                'XAmzRequestId' => self::getAwsExceptionHeader(

                    $klass,

                    'x-amz-request-id'

                ),

                'XAmznRequestId' => self::getAwsExceptionHeader(

                    $klass,

                    'x-amzn-RequestId'

                ),

            ];

        }

        if ($klass instanceof \Exception) {

            return [

                'HttpStatusCode' => self::getExceptionHttpStatusCode($klass),

                'SdkException' => substr(

                    self::getExceptionCode($klass),

                    0,

                    128

                ),

                'SdkExceptionMessage' => substr(

                    self::getExceptionMessage($klass),

                    0,

                    512

                ),

                'XAmzId2' => self::getExceptionHeader($klass, 'x-amz-id-2'),

                'XAmzRequestId' => self::getExceptionHeader($klass, 'x-amz-request-id'),

                'XAmznRequestId' => self::getExceptionHeader($klass, 'x-amzn-RequestId'),

            ];

        }

        throw new \InvalidArgumentException('Parameter must be an instance of ResultInterface, AwsException or Exception.');

    }

    private static function getResultAttemptLatency(ResultInterface $result)

    {

        if (isset($result['@metadata']['transferStats']['http'])) {

            $attempt = end($result['@metadata']['transferStats']['http']);

            if (isset($attempt['total_time'])) {

                return (int) floor($attempt['total_time'] * 1000);

            }

        }

        return null;

    }

    private static function getResultDestinationIp(ResultInterface $result)

    {

        if (isset($result['@metadata']['transferStats']['http'])) {

            $attempt = end($result['@metadata']['transferStats']['http']);

            if (isset($attempt['primary_ip'])) {

                return $attempt['primary_ip'];

            }

        }

        return null;

    }

    private static function getResultDnsLatency(ResultInterface $result)

    {

        if (isset($result['@metadata']['transferStats']['http'])) {

            $attempt = end($result['@metadata']['transferStats']['http']);

            if (isset($attempt['namelookup_time'])) {

                return (int) floor($attempt['namelookup_time'] * 1000);

            }

        }

        return null;

    }

    private static function getResultHttpStatusCode(ResultInterface $result)

    {

        return $result['@metadata']['statusCode'];

    }

    private static function getAwsExceptionAttemptLatency(AwsException $e) {

        $attempt = $e->getTransferInfo();

        if (isset($attempt['total_time'])) {

            return (int) floor($attempt['total_time'] * 1000);

        }

        return null;

    }

    private static function getAwsExceptionErrorCode(AwsException $e) {

        return $e->getAwsErrorCode();

    }

    private static function getAwsExceptionMessage(AwsException $e) {

        return $e->getAwsErrorMessage();

    }

    private static function getAwsExceptionDestinationIp(AwsException $e) {

        $attempt = $e->getTransferInfo();

        if (isset($attempt['primary_ip'])) {

            return $attempt['primary_ip'];

        }

        return null;

    }

    private static function getAwsExceptionDnsLatency(AwsException $e) {

        $attempt = $e->getTransferInfo();

        if (isset($attempt['namelookup_time'])) {

            return (int) floor($attempt['namelookup_time'] * 1000);

        }

        return null;

    }

    private static function getAwsExceptionHttpStatusCode(AwsException $e) {

        $response = $e->getResponse();

        if ($response !== null) {

            return $response->getStatusCode();

        }

        return null;

    }

    private static function getExceptionHttpStatusCode(\Exception $e) {

        if ($e instanceof ResponseContainerInterface) {

            $response = $e->getResponse();

            if ($response instanceof ResponseInterface) {

                return $response->getStatusCode();

            }

        }

        return null;

    }

    private static function getExceptionCode(\Exception $e) {

        if (!($e instanceof AwsException)) {

            return get_class($e);

        }

        return null;

    }

    private static function getExceptionMessage(\Exception $e) {

        if (!($e instanceof AwsException)) {

            return $e->getMessage();

        }

        return null;

    }

    /**

     * {@inheritdoc}

     */

    protected function populateRequestEventData(

        CommandInterface $cmd,

        RequestInterface $request,

        array $event

    ) {

        $event = parent::populateRequestEventData($cmd, $request, $event);

        $event['Type'] = 'ApiCallAttempt';

        return $event;

    }

    /**

     * {@inheritdoc}

     */

    protected function populateResultEventData(

        $result,

        array $event

    ) {

        $event = parent::populateResultEventData($result, $event);

        $provider = $this->credentialProvider;

        /** @var CredentialsInterface $credentials */

        $credentials = $provider()->wait();

        $event['AccessKey'] = $credentials->getAccessKeyId();

        $sessionToken = $credentials->getSecurityToken();

        if ($sessionToken !== null) {

            $event['SessionToken'] = $sessionToken;

        }

        if (empty($event['AttemptLatency'])) {

            $event['AttemptLatency'] = (int) (floor(microtime(true) * 1000) - $event['Timestamp']);

        }

        return $event;

    }

}