Merge pull request #2 from BinarCode/profiling

profiling

Author: binaryk

README.md

@@ -175,6 +175,49 @@ By default, all entries older than 24 hours will be pruned. You may use the hour
 $schedule->command('dev:prune --hours=48')->daily();
 ```
 
+
+## Profiling
+
+As a developer sometimes you have to measure the memory usage or time consumed for such action. Laravel Developer helps you to do so: 
+
+```php
+measure_memory(function() {
+    // some code
+});
+```
+
+Or: 
+
+```php
+$timing = \Binarcode\LaravelDeveloper\Profiling\ServerTiming::startWithoutKey();
+
+sleep(1);
+
+$timing->stopAllUnfinishedEvents();
+
+$timing->getDuration();
+```
+
+And time measure:
+
+```php
+measure_timing(function() {
+    // some code
+})
+```
+
+Or: 
+
+```php
+$memory = \Binarcode\LaravelDeveloper\Profiling\ServerMemory::measure();
+
+// some code memory consuming
+
+$memory->stop();
+
+$memory->getMemory();
+```
+
 ## Testing
 
 ``` bash

composer.json

@@ -18,7 +18,9 @@
     "require": {
         "php": "^7.4|^8.0",
         "illuminate/contracts": "^8.0",
-        "laravel/slack-notification-channel": "^2.3"
+        "illuminate/support": "^7.0|^8.0",
+        "laravel/slack-notification-channel": "^2.3",
+        "symfony/stopwatch": "^3.4"
     },
     "require-dev": {
         "orchestra/testbench": "^6.0",
@@ -29,7 +31,10 @@
         "psr-4": {
             "Binarcode\\LaravelDeveloper\\": "src",
             "Binarcode\\LaravelDeveloper\\Database\\Factories\\": "database/factories"
-        }
+        },
+        "files": [
+            "src/helpers.php"
+        ]
     },
     "autoload-dev": {
         "psr-4": {

src/Profiling/ServerMemory.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Binarcode\LaravelDeveloper\Profiling;
+
+class ServerMemory
+{
+    /** @var array */
+    protected $finishedEvents = [];
+
+    /** @var array */
+    protected $startedEvents = [];
+
+    public function start(string $key = 'measure')
+    {
+        $this->startedEvents[$key] = memory_get_usage();
+
+        return $this;
+    }
+
+    public function stop(string $key = 'measure')
+    {
+        if (! array_key_exists($key, $this->startedEvents)) {
+            return $this;
+        }
+
+        $this->setMemory(
+            $key,
+            memory_get_usage() - $this->startedEvents[$key]
+        );
+
+        unset($this->startedEvents[$key]);
+
+        return $this;
+    }
+
+    public function setMemory(string $key, $duration)
+    {
+        if (is_callable($duration)) {
+            $this->start($key);
+
+            call_user_func($duration);
+
+            $this->stop($key);
+        } else {
+            $this->finishedEvents[$key] = $duration;
+        }
+
+        return $this;
+    }
+
+    public function getMemory(string $key = 'measure', $unit = 'mb')
+    {
+        return $this->finishedEvents[$key]
+            ? collect([
+
+                'byte' => fn ($v) => $v,
+                'mb' => fn ($v) => $v / (1000 * 1000),
+                'gb' => fn ($v) => $v / (1000 * 1000 * 1000),
+
+            ])->get($unit, 'mb')($this->finishedEvents[$key])
+            : null;
+    }
+
+    public static function measure(string $key = 'measure'): ServerMemory
+    {
+        return app(static::class)->start($key);
+    }
+}

src/Profiling/ServerTiming.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Binarcode\LaravelDeveloper\Profiling;
+
+use Symfony\Component\Stopwatch\Stopwatch;
+
+class ServerTiming
+{
+    /** @var Stopwatch */
+    protected $stopwatch;
+
+    /** @var array */
+    protected $finishedEvents = [];
+
+    /** @var array */
+    protected $startedEvents = [];
+
+    public function __construct(Stopwatch $stopwatch)
+    {
+        $this->stopwatch = $stopwatch;
+    }
+
+    public function addMetric(string $metric)
+    {
+        $this->finishedEvents[$metric] = null;
+
+        return $this;
+    }
+
+    public function hasStartedEvent(string $key): bool
+    {
+        return array_key_exists($key, $this->startedEvents);
+    }
+
+    public function measure(string $key)
+    {
+        if (! $this->hasStartedEvent($key)) {
+            return $this->start($key);
+        }
+
+        return $this->stop($key);
+    }
+
+    public function start(string $key = 'measure')
+    {
+        $this->stopwatch->start($key);
+
+        $this->startedEvents[$key] = true;
+
+        return $this;
+    }
+
+    public function stop(string $key = 'measure')
+    {
+        if ($this->stopwatch->isStarted($key)) {
+            $event = $this->stopwatch->stop($key);
+
+            $this->setDuration($key, $event->getDuration());
+
+            unset($this->startedEvents[$key]);
+        }
+
+        return $this;
+    }
+
+    public function stopAllUnfinishedEvents()
+    {
+        foreach (array_keys($this->startedEvents) as $startedEventName) {
+            $this->stop($startedEventName);
+        }
+    }
+
+    public function setDuration(string $key, $duration)
+    {
+        if (is_callable($duration)) {
+            $this->start($key);
+
+            call_user_func($duration);
+
+            $this->stop($key);
+        } else {
+            $this->finishedEvents[$key] = $duration;
+        }
+
+        return $this;
+    }
+
+    public function getDuration(string $key = 'measure', $unit = 's')
+    {
+        return $this->finishedEvents[$key]
+            ? collect([
+
+                'ms' => fn ($v) => $v,
+                's' => fn ($v) => $v / 1000,
+                'm' => fn ($v) => $v / (1000 * 60),
+
+            ])->get($unit, 's')($this->finishedEvents[$key])
+            : null;
+    }
+
+    public function events(): array
+    {
+        return $this->finishedEvents;
+    }
+
+    public static function startWithoutKey(): ServerTiming
+    {
+        return app(static::class)->start('measure');
+    }
+}

src/helpers.php

@@ -0,0 +1,40 @@
+<?php
+
+use Binarcode\LaravelDeveloper\Profiling\ServerMemory;
+use Binarcode\LaravelDeveloper\Profiling\ServerTiming;
+
+if (! function_exists('measure_memory')) {
+    function measure_memory($callable = null, string $key = 'action', string $unit = 'mb')
+    {
+        /** @var ServerMemory $timing */
+        $timing = app(ServerMemory::class);
+
+        if (is_callable($callable)) {
+            $timing->setMemory($key, $callable);
+
+            return dd($timing->getMemory($key, $unit));
+        }
+
+        $timing->measure($key);
+
+        return dd($timing->getMemory($key, $unit));
+    }
+}
+
+if (! function_exists('measure_timing')) {
+    function measure_timing($callable = null, string $key = 'action')
+    {
+        /** @var ServerTiming $timing */
+        $timing = app(ServerTiming::class);
+
+        if (is_callable($callable)) {
+            $timing->setDuration($key, $callable);
+
+            return dd($timing->getDuration($key));
+        }
+
+        $timing->measure($key);
+
+        return dd($timing->getDuration($key));
+    }
+}

tests/Profiling/ServerMemoryTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Binarcode\LaravelDeveloper\Tests\Profiling;
+
+use Binarcode\LaravelDeveloper\Profiling\ServerMemory;
+use Binarcode\LaravelDeveloper\Tests\TestCase;
+use Illuminate\Support\Collection;
+
+class ServerMemoryTest extends TestCase
+{
+    public function test_can_measure_memory()
+    {
+        /**
+         * @var ServerMemory $memory
+         */
+        $memory = ServerMemory::measure();
+
+        $i = Collection::times(10000, function ($i) {
+            return $i;
+        })->all();
+
+        collect($i);
+
+        $memory->stop();
+
+        $this->assertEquals(
+            1,
+            round($memory->getMemory())
+        );
+    }
+}

tests/Profiling/ServerTimingTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Binarcode\LaravelDeveloper\Tests\Profiling;
+
+use Binarcode\LaravelDeveloper\Profiling\ServerTiming;
+use Binarcode\LaravelDeveloper\Tests\TestCase;
+
+class ServerTimingTest extends TestCase
+{
+    public function test_can_measure_timing()
+    {
+        /**
+         * @var ServerTiming $timing
+         */
+        $timing = ServerTiming::startWithoutKey();
+
+        sleep(1);
+
+        $timing->stopAllUnfinishedEvents();
+
+        $this->assertEquals(
+            1,
+            (int)$timing->getDuration()
+        );
+    }
+}