fix: don't wrap the package's own tracing listeners in listener spans

TracingEventDispatcher::makeListener() wrapped every non-wildcard,
non-queued listener in EventListenerTracer::trace(), including the
package's own instrumentation listeners (DatabaseQueryListener, and the
queue listener added next). That is wrong for two reasons:

- it records noise `listener.LaravelTrace\LaravelTrace\Tracing\...`
  spans around internal plumbing and reparents the real span
  (`database.query`) under that wrapper instead of the request span;
- the wrapper snapshots the trace context before the listener runs and
  re-applies it on close, so an instrumentation listener that
  deliberately mutates the ambient context (restoring/clearing it) has
  that change silently undone.

Skip wrapping when the listener class lives in this namespace. Factor the
listener-class resolution out of isQueuedListener() into listenerClass()
so both guards share it.

Author: AdilAzhari

src/Tracing/TracingEventDispatcher.php

@@ -29,7 +29,11 @@ public function makeListener(
             $wildcard,
         );
 
-        if ($wildcard || $this->isQueuedListener($listener)) {
+        if (
+            $wildcard
+            || $this->isQueuedListener($listener)
+            || $this->isInternalListener($listener)
+        ) {
             return $callable;
         }
 
@@ -49,11 +53,7 @@ public function makeListener(
      */
     private function isQueuedListener(mixed $listener): bool
     {
-        $class = match (true) {
-            is_string($listener) => $this->parseClassCallable($listener)[0],
-            is_array($listener) => $listener[0],
-            default => null,
-        };
+        $class = $this->listenerClass($listener);
 
         if ($class === null) {
             return false;
@@ -62,6 +62,36 @@ private function isQueuedListener(mixed $listener): bool
         return $this->handlerShouldBeQueued($class);
     }
 
+    /**
+     * The package's own queue/database instrumentation listeners manage the
+     * trace context themselves. Wrapping them in a listener span would make
+     * the wrapper re-apply the context snapshot it captured before the
+     * listener ran, undoing the context the listener deliberately cleared
+     * and leaking queue execution context after every job.
+     *
+     * @param  Closure|string|array{class-string, string}  $listener
+     */
+    private function isInternalListener(mixed $listener): bool
+    {
+        $class = $this->listenerClass($listener);
+
+        return $class !== null
+            && str_starts_with($class, __NAMESPACE__.'\\');
+    }
+
+    /**
+     * @param  Closure|string|array{class-string, string}  $listener
+     * @return class-string|null
+     */
+    private function listenerClass(mixed $listener): ?string
+    {
+        return match (true) {
+            is_string($listener) => $this->parseClassCallable($listener)[0],
+            is_array($listener) => $listener[0],
+            default => null,
+        };
+    }
+
     private function listenerName(mixed $listener): string
     {
         if (is_string($listener)) {