Merge branch 'webgrip:main' into main

.gitignore

@@ -2,6 +2,7 @@
 vendor/
 var/
 .composer/
+.phpunit.cache/
 .env
 *.private.env.json
 auth.json

README.md

@@ -55,3 +55,38 @@ class Foo
     }
 }
 ```
+
+
+### Using attributes
+> You can add the attribute 'Webgrip\TelemetryService\Core\Domain\Services\Traceable' to your class to automatically trace all methods of the class
+> You can also use this attribute to trace a single method
+
+```php
+
+#[\Webgrip\TelemetryService\Core\Domain\Attributes\Traceable]
+class Foo
+{
+    public function bar()
+    {
+        // ...
+    }
+
+    #[\Webgrip\TelemetryService\Core\Domain\Attributes\Traceable]
+    public function baz()
+    {
+        // ...
+    }
+}
+```
+}
+
+// DI configuration
+return [
+    Foo::class => function (\DI\Container $container) {
+        $factory = $container->get(\Webgrip\TelemetryService\Infrastructure\Factories\TracedClassFactory::class)
+        $foo = new Foo();
+
+        return $factory->create($foo);
+    }
+];
+```

src/Core/Domain/Attributes/Traceable.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Webgrip\TelemetryService\Core\Domain\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_CLASS)]
+class Traceable
+{
+    public function __construct(
+        public ?string $operationName = null
+    ) {}
+}

src/Core/Domain/Services/TelemetryServiceInterface.php

@@ -24,4 +24,9 @@ public function tracer(): TracerInterface;
      * @return void
      */
     public function registerException(\Throwable $exception, SpanInterface $span): void;
+
+    /**
+     * @return SpanInterface
+     */
+    public function getCurrentSpan(): SpanInterface;
 }

src/Core/Domain/Services/TracingProxyInterface.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Webgrip\TelemetryService\Core\Domain\Services;
+
+use OpenTelemetry\API\Trace\TracerInterface;
+
+interface TracingProxyInterface
+{
+    public function __construct(object $instance, TracerInterface $tracer);
+    public function __call(string $method, array $arguments): mixed;
+}

src/Infrastructure/Factories/TelemetryServiceFactory.php

@@ -20,7 +20,6 @@
 use Webgrip\TelemetryService\Core\Application\Factories\TelemetryServiceFactoryInterface;
 use Webgrip\TelemetryService\Core\Application\Factories\TracerProviderFactoryInterface;
 use Webgrip\TelemetryService\Infrastructure\Services\TelemetryService;
-use Webgrip\TelemetryService\Infrastructure\Telemetry\NoopOpenTelemetryCollector;
 
 final class TelemetryServiceFactory implements TelemetryServiceFactoryInterface
 {

src/Infrastructure/Factories/TracedClassFactory.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Webgrip\TelemetryService\Infrastructure\Factories;
+
+use ReflectionClass;
+use Webgrip\TelemetryService\Core\Domain\Attributes\Traceable;
+use Webgrip\TelemetryService\Core\Domain\Services\TelemetryServiceInterface;
+use Webgrip\TelemetryService\Infrastructure\Services\TracingProxy;
+
+class TracedClassFactory
+{
+    private TelemetryServiceInterface $telemetryService;
+
+    public function __construct(TelemetryServiceInterface $telemetryService)
+    {
+        $this->telemetryService = $telemetryService;
+    }
+
+    public function create(object $instance): object
+    {
+        $reflectionClass = new ReflectionClass($instance);
+        $hasTraceableAttribute = !empty($reflectionClass->getAttributes(Traceable::class));
+
+        if ($hasTraceableAttribute) {
+            return new TracingProxy($instance, $this->telemetryService);
+        }
+
+        // If no Traceable attribute, return the instance directly
+        return $instance;
+    }
+}

src/Infrastructure/Services/TelemetryService.php

@@ -5,6 +5,7 @@
 use Monolog\Level;
 use Monolog\Logger;
 use OpenTelemetry\API\Logs\LoggerProviderInterface;
+use OpenTelemetry\API\Trace\Span;
 use OpenTelemetry\API\Trace\SpanInterface;
 use OpenTelemetry\API\Trace\StatusCode;
 use OpenTelemetry\API\Trace\TracerInterface;
@@ -55,4 +56,12 @@ public function registerException(\Throwable $exception, SpanInterface $span): v
         $span->setStatus(StatusCode::STATUS_ERROR, $exception->getMessage());
         $span->recordException($exception);
     }
+
+    /**
+     * @return SpanInterface
+     */
+    public function getCurrentSpan(): SpanInterface
+    {
+        return Span::getCurrent();
+    }
 }

src/Infrastructure/Services/TracingProxy.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Webgrip\TelemetryService\Infrastructure\Services;
+
+use OpenTelemetry\API\Trace\SpanInterface;
+use ReflectionClass;
+use ReflectionMethod;
+use Webgrip\TelemetryService\Core\Domain\Attributes\Traceable;
+use Webgrip\TelemetryService\Core\Domain\Services\TelemetryServiceInterface;
+
+class TracingProxy
+{
+    public TelemetryServiceInterface $telemetryService;
+    private object $instance;
+
+    public SpanInterface $span;
+
+
+    private bool $traceAllMethods;
+
+    /**
+     * @param object $instance
+     * @param TelemetryServiceInterface $telemetryService
+     */
+    public function __construct(object $instance, TelemetryServiceInterface $telemetryService)
+    {
+        $this->instance = $instance;
+        $this->telemetryService = $telemetryService;
+
+        // Check if the class itself is marked as Traceable
+        $reflectionClass = new ReflectionClass($this->instance);
+        $this->traceAllMethods = !empty($reflectionClass->getAttributes(Traceable::class));
+    }
+
+    /**
+     * @param string $method
+     * @param array $arguments
+     * @return mixed
+     * @throws \ReflectionException
+     * @throws \Throwable
+     */
+    public function __call(string $method, array $arguments)
+    {
+        $reflectionMethod = new ReflectionMethod($this->instance, $method);
+        $traceableAttributes = $reflectionMethod->getAttributes(Traceable::class);
+        $traceableMethod = !empty($traceableAttributes);
+
+        // Set operation name from attribute or use the method name as fallback
+        $operationName = $method;
+        if ($traceableMethod) {
+            /** @var Traceable $traceableInstance */
+            $traceableInstance = $traceableAttributes[0]->newInstance();
+            $operationName = $traceableInstance->operationName ?? $method;
+        }
+
+        if ($this->traceAllMethods || $traceableMethod) {
+            $this->span = $this->telemetryService->tracer()
+                ->spanBuilder($operationName)
+                ->startSpan();
+
+            $scope = $this->span->activate();
+
+            try {
+                // Invoke the original method with the arguments
+                return $reflectionMethod->invokeArgs($this->instance, $arguments);
+            } catch (\Throwable $e) {
+                $this->telemetryService->registerException($e, $this->span);
+                throw $e;
+            } finally {
+                $scope->detach();
+                $this->span->end();
+            }
+        } else {
+            return $reflectionMethod->invokeArgs($this->instance, $arguments);
+        }
+    }
+}

tests/Fixtures/NonTraceableClass.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Webgrip\TelemetryService\Tests\Fixtures;
+
+class NonTraceableClass
+{
+    public function untracedMethod()
+    {
+        // Simulate some logic
+    }
+}

tests/Fixtures/PartiallyTraceableClass.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Webgrip\TelemetryService\Tests\Fixtures;
+
+use Webgrip\TelemetryService\Core\Domain\Attributes\Traceable;
+
+class PartiallyTraceableClass
+{
+    #[Traceable]
+    public function tracedMethod()
+    {
+        // Simulate some logic
+    }
+
+    public function untracedMethod()
+    {
+        // Simulate some logic
+    }
+}

tests/Fixtures/TraceableClass.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Webgrip\TelemetryService\Tests\Fixtures;
+
+use Webgrip\TelemetryService\Core\Domain\Attributes\Traceable;
+
+#[Traceable]
+class TraceableClass
+{
+    public function tracedMethod()
+    {
+        return 'traced';
+    }
+}

tests/Unit/Core/Domain/Attributes/TraceableTest.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Unit\Core\Domain\Attributes;
+
+use ReflectionClass;
+use ReflectionMethod;
+use Webgrip\TelemetryService\Core\Domain\Attributes\Traceable;
+use Webgrip\TelemetryService\Tests\Fixtures\NonTraceableClass;
+use Webgrip\TelemetryService\Tests\Fixtures\PartiallyTraceableClass;
+use Webgrip\TelemetryService\Tests\Fixtures\TraceableClass;
+use Webgrip\TelemetryService\Tests\Unit\TestCase;
+
+class TraceableTest extends TestCase
+{
+    public function testClassHasTraceableAttribute()
+    {
+        $reflection = new ReflectionClass(TraceableClass::class);
+        $attributes = $reflection->getAttributes(Traceable::class);
+
+        $this->assertNotEmpty($attributes, "Class 'ExampleClass' should have Traceable attribute");
+    }
+
+    public function testMethodHasTraceableAttribute()
+    {
+        $partiallyTracableClass = new ReflectionClass(PartiallyTraceableClass::class);
+        $tracedReflection = new ReflectionMethod(PartiallyTraceableClass::class, 'tracedMethod');
+        $untracedReflection = new ReflectionMethod(PartiallyTraceableClass::class, 'untracedMethod');;
+
+        $this->assertEmpty(
+            $partiallyTracableClass->getAttributes(Traceable::class),
+            "Method 'tracedMethod' should have Traceable attribute"
+        );
+
+        $this->assertNotEmpty(
+            $tracedReflection->getAttributes(Traceable::class),
+            "Method 'tracedMethod' should have Traceable attribute"
+        );
+        $this->assertEmpty(
+            $untracedReflection->getAttributes(Traceable::class),
+            "Method 'tracedMethod' should have Traceable attribute"
+        );
+    }
+
+    public function testMethodWithoutTraceableAttribute()
+    {
+        $reflection = new ReflectionMethod(NonTraceableClass::class, 'untracedMethod');
+        $attributes = $reflection->getAttributes(Traceable::class);
+
+        $this->assertEmpty($attributes, "Method 'untracedMethod' should not have Traceable attribute");
+    }
+}