Profiling.

Author: binaryk

composer.json

@@ -18,6 +18,7 @@
     "require": {
         "php": "^7.4|^8.0",
         "illuminate/contracts": "^8.0",
+        "illuminate/support": "^7.0|^8.0",
         "laravel/slack-notification-channel": "^2.3"
     },
     "require-dev": {

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)
+    {
+        $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));
+    }
+}