RedisCollector::connection() - Code Metrics - Inspection of "[2.x] Major refactoring" - beyondcode/laravel-websockets - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#447)

by Alexandru

created 2020-09-15 12:01 UTC

RedisCollector::connection() A

↳ Parent: RedisCollector

Complexity

Conditions	2
Paths	1

Size

Total Lines

Duplication

Lines	33
Ratio	100 %

Importance

Changes

Metric	Value
dl	33
loc	33
rs	9.392
c	0
b	0
f	0
cc	2
nc	1
nop	1

<?php

namespace BeyondCode\LaravelWebSockets\Statistics\Collectors;

use BeyondCode\LaravelWebSockets\Helpers;
use BeyondCode\LaravelWebSockets\Statistics\Statistic;
use Illuminate\Cache\RedisLock;
use Illuminate\Support\Facades\Redis;
use React\Promise\PromiseInterface;

class RedisCollector extends MemoryCollector
{
    /**
     * The Redis manager instance.
     *
     * @var \Illuminate\Redis\RedisManager
     */
    protected $redis;

    /**
     * The set name for the Redis storage.
     *
     * @var string
     */
    protected static $redisSetName = 'laravel-websockets:apps';

    /**
     * The lock name to use on Redis to avoid multiple
     * collector-to-store actions that may result
     * in multiple data points set to the store.
     *
     * @var string
     */
    protected static $redisLockName = 'laravel-websockets:collector:lock';

    /**
     * Initialize the logger.
     *
     * @return void

     */
    public function __construct()
    {
        parent::__construct();

        $this->redis = Redis::connection(

            config('websockets.replication.modes.redis.connection', 'default')
        );
    }

    /**
     * Handle the incoming websocket message.
     *
     * @param  string|int  $appId
     * @return void
     */
    public function webSocketMessage($appId)
    {
        $this->ensureAppIsInSet($appId)
            ->hincrby(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'websocket_messages_count', 1
            );
    }

    /**
     * Handle the incoming API message.
     *
     * @param  string|int  $appId
     * @return void
     */
    public function apiMessage($appId)
    {
        $this->ensureAppIsInSet($appId)
            ->hincrby(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'api_messages_count', 1
            );
    }

    /**
     * Handle the new conection.
     *
     * @param  string|int  $appId
     * @return void
     */
    public function connection($appId)

    {
        // Increment the current connections count by 1.
        $this->ensureAppIsInSet($appId)
            ->hincrby(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'current_connections_count', 1
            )
            ->then(function ($currentConnectionsCount) use ($appId) {
                // Get the peak connections count from Redis.
                $this->channelManager

                    ->getPublishClient()
                    ->hget(
                        $this->channelManager->getRedisKey($appId, null, ['stats']),

                        'peak_connections_count'
                    )
                    ->then(function ($currentPeakConnectionCount) use ($currentConnectionsCount, $appId) {
                        // Extract the greatest number between the current peak connection count
                        // and the current connection number.
                        $peakConnectionsCount = is_null($currentPeakConnectionCount)
                            ? $currentConnectionsCount
                            : max($currentPeakConnectionCount, $currentConnectionsCount);

                        // Then set it to the database.
                        $this->channelManager

                            ->getPublishClient()
                            ->hset(
                                $this->channelManager->getRedisKey($appId, null, ['stats']),

                                'peak_connections_count', $peakConnectionsCount
                            );
                    });
            });
    }

    /**
     * Handle disconnections.
     *
     * @param  string|int  $appId
     * @return void
     */
    public function disconnection($appId)

    {
        // Decrement the current connections count by 1.
        $this->ensureAppIsInSet($appId)
            ->hincrby(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'current_connections_count', -1
            )
            ->then(function ($currentConnectionsCount) use ($appId) {
                // Get the peak connections count from Redis.
                $this->channelManager

                    ->getPublishClient()
                    ->hget(
                        $this->channelManager->getRedisKey($appId, null, ['stats']),

                        'peak_connections_count'
                    )
                    ->then(function ($currentPeakConnectionCount) use ($currentConnectionsCount, $appId) {
                        // Extract the greatest number between the current peak connection count
                        // and the current connection number.
                        $peakConnectionsCount = is_null($currentPeakConnectionCount)
                            ? $currentConnectionsCount
                            : max($currentPeakConnectionCount, $currentConnectionsCount);

                        // Then set it to the database.
                        $this->channelManager

                            ->getPublishClient()
                            ->hset(
                                $this->channelManager->getRedisKey($appId, null, ['stats']),

                                'peak_connections_count', $peakConnectionsCount
                            );
                    });
            });
    }

    /**
     * Save all the stored statistics.
     *
     * @return void
     */
    public function save()
    {
        $this->lock()->get(function () {
            $this->channelManager

                ->getPublishClient()
                ->smembers(static::$redisSetName)
                ->then(function ($members) {
                    foreach ($members as $appId) {
                        $this->channelManager

                            ->getPublishClient()
                            ->hgetall($this->channelManager->getRedisKey($appId, null, ['stats']))

                            ->then(function ($list) use ($appId) {
                                if (! $list) {
                                    return;
                                }

                                $statistic = $this->arrayToStatisticInstance(
                                    $appId, Helpers::redisListToArray($list)
                                );

                                $this->createRecord($statistic, $appId);

                                $this->channelManager
                                    ->getGlobalConnectionsCount($appId)
                                    ->then(function ($currentConnectionsCount) use ($appId) {
                                        $currentConnectionsCount === 0 || is_null($currentConnectionsCount)
                                            ? $this->resetAppTraces($appId)
                                            : $this->resetStatistics($appId, $currentConnectionsCount);
                                    });
                            });
                    }
                });
        });
    }

    /**
     * Flush the stored statistics.
     *
     * @return void
     */
    public function flush()
    {
        $this->getStatistics()->then(function ($statistics) {
            foreach ($statistics as $appId => $statistic) {
                $this->resetAppTraces($appId);
            }
        });
    }

    /**
     * Get the saved statistics.
     *
     * @return PromiseInterface[array]

     */
    public function getStatistics(): PromiseInterface
    {
        return $this->channelManager

            ->getPublishClient()
            ->smembers(static::$redisSetName)
            ->then(function ($members) {
                $appsWithStatistics = [];

                foreach ($members as $appId) {
                    $this->channelManager

                        ->getPublishClient()
                        ->hgetall($this->channelManager->getRedisKey($appId, null, ['stats']))

                        ->then(function ($list) use ($appId, &$appsWithStatistics) {
                            $appsWithStatistics[$appId] = $this->arrayToStatisticInstance(
                                $appId, Helpers::redisListToArray($list)
                            );
                        });
                }

                return $appsWithStatistics;
            });
    }

    /**
     * Get the saved statistics for an app.
     *
     * @param  string|int  $appId
     * @return PromiseInterface[\BeyondCode\LaravelWebSockets\Statistics\Statistic|null]

     */
    public function getAppStatistics($appId): PromiseInterface
    {
        return $this->channelManager

            ->getPublishClient()
            ->hgetall($this->channelManager->getRedisKey($appId, null, ['stats']))

            ->then(function ($list) use ($appId) {
                return $this->arrayToStatisticInstance(
                    $appId, Helpers::redisListToArray($list)
                );
            });
    }

    /**
     * Reset the statistics to a specific connection count.
     *
     * @param  string|int  $appId
     * @param  int  $currentConnectionCount
     * @return void
     */
    public function resetStatistics($appId, int $currentConnectionCount)
    {
        $this->channelManager

            ->getPublishClient()
            ->hset(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'current_connections_count', $currentConnectionCount
            );

        $this->channelManager

            ->getPublishClient()
            ->hset(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'peak_connections_count', $currentConnectionCount
            );

        $this->channelManager

            ->getPublishClient()
            ->hset(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'websocket_messages_count', 0
            );

        $this->channelManager

            ->getPublishClient()
            ->hset(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'api_messages_count', 0
            );
    }

    /**
     * Remove all app traces from the database if no connections have been set
     * in the meanwhile since last save.
     *
     * @param  string|int  $appId
     * @return void
     */
    public function resetAppTraces($appId)
    {
        $this->channelManager

            ->getPublishClient()
            ->hdel(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'current_connections_count'
            );

        $this->channelManager

            ->getPublishClient()
            ->hdel(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'peak_connections_count'
            );

        $this->channelManager

            ->getPublishClient()
            ->hdel(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'websocket_messages_count'
            );

        $this->channelManager

            ->getPublishClient()
            ->hdel(
                $this->channelManager->getRedisKey($appId, null, ['stats']),

                'api_messages_count'
            );

        $this->channelManager

            ->getPublishClient()
            ->srem(static::$redisSetName, $appId);
    }

    /**
     * Ensure the app id is stored in the Redis database.
     *
     * @param  string|int  $appId
     * @return \Clue\React\Redis\Client
     */
    protected function ensureAppIsInSet($appId)
    {
        $this->channelManager

            ->getPublishClient()
            ->sadd(static::$redisSetName, $appId);

        return $this->channelManager->getPublishClient();

    }

    /**
     * Get a new RedisLock instance to avoid race conditions.
     *
     * @return \Illuminate\Cache\CacheLock
     */
    protected function lock()
    {
        return new RedisLock($this->redis, static::$redisLockName, 0);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Transform a key-value pair to a Statistic instance.
     *
     * @param  string|int  $appId
     * @param  array  $stats
     * @return \BeyondCode\LaravelWebSockets\Statistics\Statistic
     */
    protected function arrayToStatisticInstance($appId, array $stats)
    {
        return Statistic::new($appId)
            ->setCurrentConnectionsCount($stats['current_connections_count'] ?? 0)
            ->setPeakConnectionsCount($stats['peak_connections_count'] ?? 0)
            ->setWebSocketMessagesCount($stats['websocket_messages_count'] ?? 0)
            ->setApiMessagesCount($stats['api_messages_count'] ?? 0);
    }
}


1			<?php
2
3			namespace BeyondCode\LaravelWebSockets\Statistics\Collectors;
4
5			use BeyondCode\LaravelWebSockets\Helpers;
6			use BeyondCode\LaravelWebSockets\Statistics\Statistic;
7			use Illuminate\Cache\RedisLock;
8			use Illuminate\Support\Facades\Redis;
9			use React\Promise\PromiseInterface;
10
11			class RedisCollector extends MemoryCollector
12			{
13			/**
14			* The Redis manager instance.
15			*
16			* @var \Illuminate\Redis\RedisManager
17			*/
18			protected $redis;
19
20			/**
21			* The set name for the Redis storage.
22			*
23			* @var string
24			*/
25			protected static $redisSetName = 'laravel-websockets:apps';
26
27			/**
28			* The lock name to use on Redis to avoid multiple
29			* collector-to-store actions that may result
30			* in multiple data points set to the store.
31			*
32			* @var string
33			*/
34			protected static $redisLockName = 'laravel-websockets:collector:lock';
35
36			/**
37			* Initialize the logger.
38			*
39			* @return void
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-09-10 20:15 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...

beyondcode / laravel-websockets

Pull Request — master (#447)

RedisCollector::connection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like