feat: implemented support for listening to ticks

README.md

@@ -27,7 +27,7 @@ Request a [profiler](./src/ProfilerInterface.php) as a dependency and call a `pr
 ```php
 namespace PetrKnap\Profiler;
 
-function something(ProfilerInterface $profiler): string {
+function doSomething(ProfilerInterface $profiler): string {
     // do something without profiling
     return $profiler->profile(function (): string {
         // do something
@@ -46,8 +46,8 @@ It can be easily enabled, or disabled **through the DI**, which provides either
 ```php
 namespace PetrKnap\Profiler;
 
-echo something(new Profiler());
-echo something(new NullProfiler());
+echo doSomething(new Profiler());
+echo doSomething(new NullProfiler());
 ```
 
 ### Cascade profiling
@@ -59,14 +59,31 @@ namespace PetrKnap\Profiler;
 
 echo (new Profiler())->profile(function (ProfilerInterface $profiler): string {
     // do something before something
-    return something($profiler);
+    return doSomething($profiler);
 })->process(fn (ProfileInterface $profile) => printf(
     'It took %.1f s to do something before something and something, there are %d children profiles.',
     $profile->getDuration(),
     count($profile->getChildren()),
 ));
 ```
 
+### Tick listening
+
+For greater precision, you can use measurements at each tick.
+This will result in **very detailed code tracking**, which can degrade the performance of the monitored application.
+
+```php
+declare(ticks=1); // this declaration is important
+
+namespace PetrKnap\Profiler;
+
+$profiling = Profiling::start(listenToTicks: true);
+doSomething(new NullProfiler());
+$profile = $profiling->finish();
+
+printf('There are %d memory usage records.', count($profile->getMemoryUsages()));
+```
+
 ---
 
 Run `composer require petrknap/profiler` to install it.

src/Profile.php

@@ -18,13 +18,19 @@
  */
 final class Profile implements ProcessableProfileInterface, ProfileWithOutputInterface
 {
+    public const DO_NOT_LISTEN_TO_TICKS = false;
+
     private const MICROTIME_FORMAT = '%.6f';
 
     private ProfileState $state;
     private OptionalFloat $timeBefore;
     private OptionalInt $memoryUsageBefore;
     private OptionalFloat $timeAfter;
     private OptionalInt $memoryUsageAfter;
+    /**
+     * @var array<numeric-string, int>
+     */
+    private array $memoryUsages = [];
     /**
      * @var array<ProfileInterface>
      */
@@ -34,8 +40,9 @@ final class Profile implements ProcessableProfileInterface, ProfileWithOutputInt
      */
     private Optional $outputOption;
 
-    public function __construct()
-    {
+    public function __construct(
+        private readonly bool $listenToTicks = self::DO_NOT_LISTEN_TO_TICKS,
+    ) {
         $this->state = ProfileState::Created;
         $this->timeBefore = OptionalFloat::empty();
         $this->memoryUsageBefore = OptionalInt::empty();
@@ -54,6 +61,7 @@ public function start(): void
         $this->state = ProfileState::Started;
         $this->timeBefore = OptionalFloat::of(microtime(as_float: true));
         $this->memoryUsageBefore = OptionalInt::of(memory_get_usage(real_usage: true));
+        $this->startTicker();
     }
 
     /**
@@ -63,11 +71,31 @@ public function finish(): void
     {
         Exception\ProfileCouldNotBeFinished::throwIf($this->state !== ProfileState::Started);
 
+        $this->stopTicker();
         $this->state = ProfileState::Finished;
         $this->timeAfter = OptionalFloat::of(microtime(as_float: true));
         $this->memoryUsageAfter = OptionalInt::of(memory_get_usage(real_usage: true));
     }
 
+    public function stopTicker(): void
+    {
+        if ($this->listenToTicks) {
+            unregister_tick_function([$this, 'tick']);
+        }
+    }
+
+    public function startTicker(): void
+    {
+        if ($this->listenToTicks) {
+            register_tick_function([$this, 'tick']);
+        }
+    }
+
+    public function tick(): void
+    {
+        $this->memoryUsages[sprintf(self::MICROTIME_FORMAT, microtime(as_float: true))] = memory_get_usage(real_usage: true);
+    }
+
     /**
      * @throws Exception\ProfileCouldNotBeProcessed
      */
@@ -120,6 +148,7 @@ public function getMemoryUsages(): array
         $memoryUsages = [
             sprintf(self::MICROTIME_FORMAT, $this->timeBefore->orElseThrow()) => $this->memoryUsageBefore->orElseThrow(),
             sprintf(self::MICROTIME_FORMAT, $this->timeAfter->orElseThrow()) => $this->memoryUsageAfter->orElseThrow(),
+            ...$this->memoryUsages,
         ];
         foreach ($this->children as $child) {
             $memoryUsages = array_merge(

src/Profiler.php

@@ -11,16 +11,26 @@
      */
     protected Profile|null $parentProfile = null;
 
+    public function __construct(
+        private readonly bool $listenToTicks = Profile::DO_NOT_LISTEN_TO_TICKS,
+    ) {
+    }
+
     public function profile(callable $callable): ProcessableProfileInterface & ProfileWithOutputInterface
     {
-        $profiling = Profiling::start();
-        $output = $callable($profiling->createNestedProfiler());
-        /** @var Profile<mixed> $profile */
-        $profile = $profiling->finish();
-        $profile->setOutput($output);
+        $this->parentProfile?->stopTicker();
+        try {
+            $profiling = Profiling::start($this->listenToTicks);
+            $output = $callable($profiling->createNestedProfiler());
+            /** @var Profile<mixed> $profile */
+            $profile = $profiling->finish();
+            $profile->setOutput($output);
 
-        $this->parentProfile?->addChild($profile);
+            $this->parentProfile?->addChild($profile);
 
-        return $profile; // @phpstan-ignore return.type
+            return $profile; // @phpstan-ignore return.type
+        } finally {
+            $this->parentProfile?->startTicker();
+        }
     }
 }

src/Profiling.php

@@ -13,15 +13,17 @@ final class Profiling
      */
     private function __construct(
         private readonly Profile $profile,
+        private readonly bool $listenToTicks,
     ) {
     }
 
-    public static function start(): self
-    {
-        $profile = new Profile();
+    public static function start(
+        bool $listenToTicks = Profile::DO_NOT_LISTEN_TO_TICKS,
+    ): self {
+        $profile = new Profile($listenToTicks);
         $profile->start();
 
-        return new self($profile);
+        return new self($profile, $listenToTicks);
     }
 
     /**
@@ -44,13 +46,17 @@ public function createNestedProfiler(): ProfilerInterface
     {
         Exception\ProfilingHasBeenAlreadyFinished::throwIf($this->wasFinished);
 
-        return new class ($this->profile) extends Profiler {
+        return new class ($this->listenToTicks, $this->profile) extends Profiler {
             /**
              * @param Profile<mixed> $parentProfile
              */
             public function __construct(
+                bool $listenToTicks,
                 Profile $parentProfile,
             ) {
+                parent::__construct(
+                    listenToTicks: $listenToTicks,
+                );
                 $this->parentProfile = $parentProfile;
             }
         };

tests/ProfileTest.php

@@ -1,9 +1,11 @@
 <?php
 
 declare(strict_types=1);
+declare(ticks=1);
 
 namespace PetrKnap\Profiler;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 final class ProfileTest extends TestCase
@@ -23,4 +25,26 @@ public function testAddsChildren(): void
 
         self::assertSame([$child1, $child2], $parent->getChildren());
     }
+
+    #[DataProvider('dataListensToTicks')]
+    public function testListensToTicks(bool|null $shouldItListen): void
+    {
+        $profile = $shouldItListen === null ? new Profile() : new Profile(listenToTicks: $shouldItListen);
+        $profile->start();
+        for ($i = 0; $i < 5; $i++) {
+            $i = (fn (int $i): int => $i)($i);
+        }
+        $profile->finish();
+
+        self::assertCount($shouldItListen === true ? 9 : 2, $profile->getMemoryUsages());
+    }
+
+    public static function dataListensToTicks(): array
+    {
+        return [
+            'default' => [null],
+            'yes' => [true],
+            'no' => [false],
+        ];
+    }
 }

tests/ReadmeTest.php

@@ -24,6 +24,7 @@ public static function getExpectedOutputsOfPhpExamples(): iterable
             'long-term-profiling' => '',
             'how-to-enable-disable-it' => 'It took 0.0 s to do something.' . 'something' . 'something',
             'cascade-profiling' => 'It took 0.0 s to do something.' . 'It took 0.0 s to do something before something and something, there are 1 children profiles.' . 'something',
+            'tick-listening' => 'There are 4 memory usage records.',
         ];
     }
 }