fix: guard against a mixed buffer

Author: cedricziel

src/Utils/Test/src/TraceStructureAssertionTrait.php

@@ -56,23 +56,29 @@ public function assertTraceStructure($spans, array $expectedStructure, bool $str
     }
 
     /**
-     * Converts spans to an array if they are in a different format.
+     * Converts spans to an array if they are in a different format and filters out non-span items.
      *
+     * @psalm-suppress UnusedVariable
      * @param array|ArrayObject|Traversable $spans
      * @return array
      */
     private function convertSpansToArray($spans): array
     {
-        if (is_array($spans)) {
-            return $spans;
-        }
+        $array = [];
 
-        if ($spans instanceof ArrayObject || $spans instanceof Traversable) {
-            return iterator_to_array($spans);
+        if (is_array($spans)) {
+            $array = $spans;
+        } elseif ($spans instanceof ArrayObject || $spans instanceof Traversable) {
+            $array = iterator_to_array($spans);
+        } else {
+            /** @phpstan-ignore deadCode.unreachable */
+            throw new \InvalidArgumentException('Spans must be an array, ArrayObject, or Traversable');
         }
 
-        /** @phpstan-ignore deadCode.unreachable */
-        throw new \InvalidArgumentException('Spans must be an array, ArrayObject, or Traversable');
+        // Filter out non-span items
+        return array_filter($array, function ($item) {
+            return $item instanceof ImmutableSpan;
+        });
     }
 
     /**
@@ -86,10 +92,7 @@ private function buildSpanMap(array $spans): array
         $spanMap = [];
 
         foreach ($spans as $span) {
-            if (!$span instanceof ImmutableSpan) {
-                throw new \InvalidArgumentException('Each span must be an instance of ImmutableSpan');
-            }
-
+            // All non-span items should have been filtered out in convertSpansToArray
             $spanMap[$span->getSpanId()] = [
                 'span' => $span,
                 'children' => [],

src/Utils/Test/tests/Unit/MixedBufferTest.php

@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\TestUtils\Tests\Unit;
+
+use ArrayObject;
+use OpenTelemetry\API\Logs\LogRecord;
+use OpenTelemetry\API\Trace\SpanKind;
+use OpenTelemetry\SDK\Trace\ImmutableSpan;
+use OpenTelemetry\SDK\Trace\SpanExporter\InMemoryExporter;
+use OpenTelemetry\SDK\Trace\SpanProcessor\SimpleSpanProcessor;
+use OpenTelemetry\SDK\Trace\TracerProvider;
+use OpenTelemetry\TestUtils\TraceStructureAssertionTrait;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Test to demonstrate that TraceStructureAssertionTrait only works with spans.
+ */
+class MixedBufferTest extends TestCase
+{
+    use TraceStructureAssertionTrait;
+
+    private ArrayObject $sharedBuffer;
+    private TracerProvider $tracerProvider;
+
+    protected function setUp(): void
+    {
+        // Create a shared buffer for both spans and logrecords
+        $this->sharedBuffer = new ArrayObject();
+
+        // Create a TracerProvider with an InMemoryExporter using the shared buffer
+        $this->tracerProvider = new TracerProvider(
+            new SimpleSpanProcessor(
+                new InMemoryExporter($this->sharedBuffer)
+            )
+        );
+    }
+
+    /**
+     * Test that demonstrates the trait now automatically filters out logrecords.
+     */
+    public function test_trait_automatically_filters_logrecords(): void
+    {
+        // Create a span
+        $tracer = $this->tracerProvider->getTracer('test-tracer');
+        $span = $tracer->spanBuilder('test-span')
+            ->setSpanKind(SpanKind::KIND_SERVER)
+            ->startSpan();
+        $span->setAttribute('attribute.one', 'value1');
+        $span->end();
+
+        // Manually add a logrecord to the shared buffer
+        $logRecord = new LogRecord('Test log message');
+        $this->sharedBuffer->append($logRecord);
+
+        // Define the expected structure
+        $expectedStructure = [
+            [
+                'name' => 'test-span',
+                'kind' => SpanKind::KIND_SERVER,
+                'attributes' => [
+                    'attribute.one' => 'value1',
+                ],
+            ],
+        ];
+
+        // This should now pass because the trait automatically filters out logrecords
+        $this->assertTraceStructure($this->sharedBuffer, $expectedStructure);
+    }
+
+    /**
+     * Test that demonstrates the manual solution to filter out logrecords still works.
+     */
+    public function test_manual_filtering_of_logrecords_still_works(): void
+    {
+        // Create a span
+        $tracer = $this->tracerProvider->getTracer('test-tracer');
+        $span = $tracer->spanBuilder('test-span')
+            ->setSpanKind(SpanKind::KIND_SERVER)
+            ->startSpan();
+        $span->setAttribute('attribute.one', 'value1');
+        $span->end();
+
+        // Manually add a logrecord to the shared buffer
+        $logRecord = new LogRecord('Test log message');
+        $this->sharedBuffer->append($logRecord);
+
+        // Define the expected structure
+        $expectedStructure = [
+            [
+                'name' => 'test-span',
+                'kind' => SpanKind::KIND_SERVER,
+                'attributes' => [
+                    'attribute.one' => 'value1',
+                ],
+            ],
+        ];
+
+        // Filter the buffer to only include spans
+        $spansOnly = array_filter(iterator_to_array($this->sharedBuffer), function ($item) {
+            return $item instanceof ImmutableSpan;
+        });
+
+        // This should pass because we've filtered out the logrecords
+        $this->assertTraceStructure($spansOnly, $expectedStructure);
+    }
+}