Improve tracing logic

Author: Kirill Nesmeyanov

src/Runtime/Parser/TraceableTypeParser.php

@@ -17,21 +17,33 @@ public function __construct(
 
     public function getStatementByDefinition(#[Language('PHP')] string $definition): TypeStatement
     {
-        $span = $this->tracer->start('type-lang::parsing');
+        $span = $this->tracer->start(\sprintf('Parsing by definition [%s]', $definition));
 
         try {
-            return $this->delegate->getStatementByDefinition($definition);
+            $span->setAttribute('value', $definition);
+
+            $result = $this->delegate->getStatementByDefinition($definition);
+
+            $span->setAttribute('result', $result);
+
+            return $result;
         } finally {
             $span->stop();
         }
     }
 
     public function getStatementByValue(mixed $value): TypeStatement
     {
-        $span = $this->tracer->start('type-lang::parsing');
+        $span = $this->tracer->start(\sprintf('Parsing by value [%s]', \get_debug_type($value)));
 
         try {
-            return $this->delegate->getStatementByValue($value);
+            $span->setAttribute('value', $value);
+
+            $result = $this->delegate->getStatementByValue($value);
+
+            $span->setAttribute('result', $result);
+
+            return $result;
         } finally {
             $span->stop();
         }

src/Runtime/Repository/TraceableTypeRepository.php

@@ -24,10 +24,14 @@ public function getTypeByDefinition(
         string $definition,
         ?\ReflectionClass $context = null,
     ): TypeInterface {
-        $span = $this->tracer->start('type-lang::fetching');
+        $span = $this->tracer->start(\sprintf('Fetching by definition [%s]', $definition));
 
         try {
+            $span->setAttribute('value', $definition);
+
             $result = $this->delegate->getTypeByDefinition($definition, $context);
+
+            $span->setAttribute('result', $result);
         } finally {
             $span->stop();
         }
@@ -37,10 +41,14 @@ public function getTypeByDefinition(
 
     public function getTypeByValue(mixed $value, ?\ReflectionClass $context = null): TypeInterface
     {
-        $span = $this->tracer->start('type-lang::fetching');
+        $span = $this->tracer->start(\sprintf('Fetching by value [%s]', \get_debug_type($value)));
 
         try {
+            $span->setAttribute('value', $value);
+
             $result = $this->delegate->getTypeByValue($value, $context);
+
+            $span->setAttribute('result', $result);
         } finally {
             $span->stop();
         }
@@ -50,10 +58,14 @@ public function getTypeByValue(mixed $value, ?\ReflectionClass $context = null):
 
     public function getTypeByStatement(TypeStatement $statement, ?\ReflectionClass $context = null): TypeInterface
     {
-        $span = $this->tracer->start('type-lang::fetching');
+        $span = $this->tracer->start(\sprintf('Fetching by statement "%s"', \get_debug_type($statement)));
 
         try {
+            $span->setAttribute('value', $statement);
+
             $result = $this->delegate->getTypeByStatement($statement, $context);
+
+            $span->setAttribute('result', $result);
         } finally {
             $span->stop();
         }

src/Runtime/Repository/TraceableTypeRepository/TraceableType.php

@@ -5,6 +5,7 @@
 namespace TypeLang\Mapper\Runtime\Repository\TraceableTypeRepository;
 
 use TypeLang\Mapper\Runtime\Context;
+use TypeLang\Mapper\Runtime\Path\Entry\ObjectEntry;
 use TypeLang\Mapper\Runtime\Tracing\TracerInterface;
 use TypeLang\Mapper\Type\TypeInterface;
 
@@ -14,34 +15,96 @@
  */
 final class TraceableType implements TypeInterface
 {
+    /**
+     * @var non-empty-string
+     */
+    private readonly string $name;
+
     public function __construct(
         private readonly TracerInterface $tracer,
         private readonly TypeInterface $delegate,
-    ) {}
+    ) {
+        $this->name = self::getShortName($this->delegate::class)
+            . '#' . \spl_object_id($this->delegate);
+    }
+
+    /**
+     * @param non-empty-string $fqn
+     *
+     * @return non-empty-string
+     */
+    private static function getShortName(string $fqn): string
+    {
+        /** @var non-empty-list<non-empty-string> $parts */
+        $parts = \explode('\\', $fqn);
+
+        return \end($parts);
+    }
+
+    /**
+     * @return list<non-empty-string>
+     */
+    private static function getPath(Context $context): array
+    {
+        $result = [];
+
+        foreach ($context->getPath() as $entry) {
+            $result[] = match (true) {
+                $entry instanceof ObjectEntry => self::getShortName($entry->value),
+                default => (string) $entry,
+            };
+        }
+
+        /** @var list<non-empty-string> */
+        return $result;
+    }
+
+    private static function getCurrentPath(Context $context): string
+    {
+        $result = self::getPath($context);
+
+        if ($result === []) {
+            return '<root>';
+        }
+
+        return \end($result);
+    }
 
     public function match(mixed $value, Context $context): bool
     {
-        $span = $this->tracer->start(\sprintf(
-            'type-lang::matching(%s)',
-            $this->delegate::class . '#' . \spl_object_id($this->delegate),
-        ));
+        $span = $this->tracer->start(\vsprintf('Type matching [%s at %s]', [
+            $this->name,
+            self::getCurrentPath($context),
+        ]));
 
         try {
-            return $this->delegate->match($value, $context);
+            $span->setAttribute('value', $value);
+
+            $result = $this->delegate->match($value, $context);
+
+            $span->setAttribute('result', $result);
+
+            return $result;
         } finally {
             $span->stop();
         }
     }
 
     public function cast(mixed $value, Context $context): mixed
     {
-        $span = $this->tracer->start(\sprintf(
-            'type-lang::casting(%s)',
-            $this->delegate::class . '#' . \spl_object_id($this->delegate),
-        ));
+        $span = $this->tracer->start(\vsprintf('Type casting [%s at %s]', [
+            $this->name,
+            self::getCurrentPath($context),
+        ]));
 
         try {
-            return $this->delegate->cast($value, $context);
+            $span->setAttribute('value', $value);
+
+            $result = $this->delegate->cast($value, $context);
+
+            $span->setAttribute('result', $result);
+
+            return $result;
         } finally {
             $span->stop();
         }

src/Runtime/Tracing/SpanInterface.php

@@ -6,6 +6,13 @@
 
 interface SpanInterface
 {
+    /**
+     * Sets a single attribute on the span.
+     *
+     * @param non-empty-string $key
+     */
+    public function setAttribute(string $key, mixed $value): void;
+
     /**
      * Marks this span as completed.
      */

src/Runtime/Tracing/SymfonyStopwatchTracer.php

@@ -9,14 +9,18 @@
 
 final class SymfonyStopwatchTracer implements TracerInterface
 {
+    /**
+     * @param non-empty-string|null $category
+     */
     public function __construct(
         public readonly Stopwatch $stopwatch,
+        private readonly ?string $category = 'type-lang',
     ) {}
 
     public function start(string $name): SpanInterface
     {
         return new SymfonyStopwatchSpan(
-            event: $this->stopwatch->start($name),
+            event: $this->stopwatch->start($name, $this->category),
         );
     }
 }

src/Runtime/Tracing/SymfonyStopwatchTracer/SymfonyStopwatchSpan.php

@@ -17,6 +17,12 @@ public function __construct(
         private readonly StopwatchEvent $event,
     ) {}
 
+    public function setAttribute(string $key, mixed $value): void
+    {
+        // Do nothing
+        // Symfony stopwatch does not support attributes
+    }
+
     public function stop(): void
     {
         $this->event->stop();