diff --git a/.changeset/@graphql-hive_plugin-opentelemetry-1636-dependencies.md b/.changeset/@graphql-hive_plugin-opentelemetry-1636-dependencies.md
new file mode 100644
index 000000000..655af5d38
--- /dev/null
+++ b/.changeset/@graphql-hive_plugin-opentelemetry-1636-dependencies.md
@@ -0,0 +1,7 @@
+---
+'@graphql-hive/plugin-opentelemetry': patch
+---
+
+dependencies updates: 
+
+- Added dependency [`@graphql-tools/executor@^1.4.9` ↗︎](https://www.npmjs.com/package/@graphql-tools/executor/v/1.4.9) (to `dependencies`)
diff --git a/e2e/opentelemetry/opentelemetry.e2e.ts b/e2e/opentelemetry/opentelemetry.e2e.ts
index 344b69665..32e1a6cd2 100644
--- a/e2e/opentelemetry/opentelemetry.e2e.ts
+++ b/e2e/opentelemetry/opentelemetry.e2e.ts
@@ -55,11 +55,17 @@ type JaegerTraceResource = {
   tags: JaegerTraceTag[];
 };
 
+type JaegerTraceLog = {
+  timestamp: number;
+  fields: JaegerTraceTag[];
+};
+
 type JaegerTraceSpan = {
   traceID: string;
   spanID: string;
   operationName: string;
   tags: Array<JaegerTraceTag>;
+  logs: Array<JaegerTraceLog>;
   references: Array<{ refType: string; spanID: string; traceID: string }>;
 };
 
@@ -402,6 +408,30 @@ describe('OpenTelemetry', () => {
           expect(relevantTrace?.spans).toContainEqual(
             expect.objectContaining({ operationName: 'POST /graphql' }),
           );
+
+          const operationSpan = relevantTrace!.spans.find(
+            (span) => span.operationName === 'graphql.operation',
+          );
+
+          expect(operationSpan?.logs).toContainEqual(
+            expect.objectContaining({
+              fields: expect.arrayContaining([
+                expect.objectContaining({
+                  key: 'event',
+                  value: 'graphql.error',
+                }),
+                expect.objectContaining({
+                  key: 'hive.graphql.error.locations',
+                  value: '["1:13"]',
+                }),
+                expect.objectContaining({
+                  key: 'hive.graphql.error.message',
+                  value: 'Syntax Error: Expected Name, found <EOF>.',
+                }),
+              ]),
+            }),
+          );
+
           expect(relevantTrace?.spans).toContainEqual(
             expect.objectContaining({
               operationName: 'graphql.parse',
@@ -416,7 +446,7 @@ describe('OpenTelemetry', () => {
                 }),
                 expect.objectContaining({
                   key: 'otel.status_description',
-                  value: 'Syntax Error: Expected Name, found <EOF>.',
+                  value: 'GraphQL Parse Error',
                 }),
                 expect.objectContaining({
                   key: 'hive.graphql.error.count',
@@ -477,6 +507,53 @@ describe('OpenTelemetry', () => {
           expect(relevantTrace?.spans).toContainEqual(
             expect.objectContaining({ operationName: 'POST /graphql' }),
           );
+          expect(relevantTrace?.spans).toContainEqual(
+            expect.objectContaining({
+              operationName: 'graphql.operation',
+              tags: expect.arrayContaining([
+                expect.objectContaining({
+                  key: 'otel.status_code',
+                  value: 'ERROR',
+                }),
+                expect.objectContaining({
+                  key: 'error',
+                  value: true,
+                }),
+                expect.objectContaining({
+                  key: 'otel.status_description',
+                  value: 'GraphQL Validation Error',
+                }),
+                expect.objectContaining({
+                  key: 'hive.graphql.error.count',
+                  value: 1,
+                }),
+              ]),
+            }),
+          );
+          const operationSpan = relevantTrace!.spans.find(
+            (span) => span.operationName === 'graphql.operation',
+          );
+
+          expect(operationSpan?.logs).toContainEqual(
+            expect.objectContaining({
+              fields: expect.arrayContaining([
+                expect.objectContaining({
+                  key: 'event',
+                  value: 'graphql.error',
+                }),
+                expect.objectContaining({
+                  key: 'hive.graphql.error.locations',
+                  value: '["1:9"]',
+                }),
+                expect.objectContaining({
+                  key: 'hive.graphql.error.message',
+                  value:
+                    'Cannot query field "nonExistentField" on type "Query".',
+                }),
+              ]),
+            }),
+          );
+
           expect(relevantTrace?.spans).toContainEqual(
             expect.objectContaining({ operationName: 'graphql.parse' }),
           );
@@ -494,8 +571,7 @@ describe('OpenTelemetry', () => {
                 }),
                 expect.objectContaining({
                   key: 'otel.status_description',
-                  value:
-                    'Cannot query field "nonExistentField" on type "Query".',
+                  value: 'GraphQL Validation Error',
                 }),
                 expect.objectContaining({
                   key: 'hive.graphql.error.count',
diff --git a/package.json b/package.json
index 03f1021dd..c32db6ff4 100644
--- a/package.json
+++ b/package.json
@@ -66,6 +66,8 @@
     "@graphql-mesh/types": "0.104.13",
     "@graphql-mesh/utils": "0.104.13",
     "@graphql-tools/delegate": "workspace:^",
+    "@graphql-tools/executor": "1.5.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b",
+    "@graphql-tools/utils": "10.10.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b",
     "@opentelemetry/otlp-exporter-base@npm:0.203.0": "patch:@opentelemetry/otlp-exporter-base@npm%3A0.203.0#~/.yarn/patches/@opentelemetry-otlp-exporter-base-npm-0.203.0-183dcac0e6.patch",
     "@rollup/plugin-node-resolve@npm:^15.2.3": "patch:@rollup/plugin-node-resolve@npm%3A16.0.1#~/.yarn/patches/@rollup-plugin-node-resolve-npm-16.0.1-2936474bab.patch",
     "@vitest/snapshot": "patch:@vitest/snapshot@npm:3.1.2#~/.yarn/patches/@vitest-snapshot-npm-3.1.1-4d18cf86dc.patch",
diff --git a/packages/batch-execute/src/mergeRequests.ts b/packages/batch-execute/src/mergeRequests.ts
index 73c333ff1..5ff1dcc51 100644
--- a/packages/batch-execute/src/mergeRequests.ts
+++ b/packages/batch-execute/src/mergeRequests.ts
@@ -18,6 +18,7 @@ import {
   VariableNode,
   visit,
 } from 'graphql';
+import { abortSignalAll } from '../../signal/src/abortSignalAll.js';
 import { createPrefix } from './prefix.js';
 
 /**
@@ -70,12 +71,19 @@ export function mergeRequests(
   const mergedSelections: Array<SelectionNode> = [];
   const mergedFragmentDefinitions: Array<FragmentDefinitionNode> = [];
   let mergedExtensions: Record<string, any> = Object.create(null);
+  let schemaCoordinateInErrors: boolean | undefined = false;
+  const signals: AbortSignal[] = [];
 
   for (let index = 0; index < requests.length; index++) {
     const request = requests[index];
     if (request) {
+      schemaCoordinateInErrors ||= request.schemaCoordinateInErrors;
       const prefixedRequests = prefixRequest(createPrefix(index), request);
 
+      if (request.signal) {
+        signals.push(request.signal);
+      }
+
       for (const def of prefixedRequests.document.definitions) {
         if (isOperationDefinition(def)) {
           mergedSelections.push(...def.selectionSet.selections);
@@ -129,6 +137,8 @@ export function mergeRequests(
     info: firstRequest.info,
     operationType,
     rootValue: firstRequest.rootValue,
+    signal: abortSignalAll(signals),
+    schemaCoordinateInErrors,
   };
 }
 
diff --git a/packages/plugins/opentelemetry/package.json b/packages/plugins/opentelemetry/package.json
index d9624ad1d..6ff77935a 100644
--- a/packages/plugins/opentelemetry/package.json
+++ b/packages/plugins/opentelemetry/package.json
@@ -69,6 +69,7 @@
     "@graphql-mesh/transport-common": "workspace:^",
     "@graphql-mesh/types": "^0.104.14",
     "@graphql-mesh/utils": "^0.104.14",
+    "@graphql-tools/executor": "^1.4.9",
     "@graphql-tools/utils": "^10.10.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/api-logs": "^0.207.0",
diff --git a/packages/plugins/opentelemetry/src/attributes.ts b/packages/plugins/opentelemetry/src/attributes.ts
index 3916ed89f..489121c4d 100644
--- a/packages/plugins/opentelemetry/src/attributes.ts
+++ b/packages/plugins/opentelemetry/src/attributes.ts
@@ -25,6 +25,15 @@ export const SEMATTRS_HIVE_GRAPHQL_OPERATION_HASH =
   'hive.graphql.operation.hash';
 export const SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT = 'hive.graphql.error.count';
 export const SEMATTRS_HIVE_GRAPHQL_ERROR_CODES = 'hive.graphql.error.codes';
+export const SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATES =
+  'hive.graphql.error.coordinates';
+export const SEMATTRS_HIVE_GRAPHQL_ERROR_CODE = 'hive.graphql.error.code';
+export const SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATE =
+  'hive.graphql.error.coordinate';
+export const SEMATTRS_HIVE_GRAPHQL_ERROR_PATH = 'hive.graphql.error.path';
+export const SEMATTRS_HIVE_GRAPHQL_ERROR_MESSAGE = 'hive.graphql.error.message';
+export const SEMATTRS_HIVE_GRAPHQL_ERROR_LOCATIONS =
+  'hive.graphql.error.locations';
 
 // Gateway-specific attributes
 export const SEMATTRS_HIVE_GATEWAY_UPSTREAM_SUBGRAPH_NAME =
diff --git a/packages/plugins/opentelemetry/src/hive-span-processor.ts b/packages/plugins/opentelemetry/src/hive-span-processor.ts
index d0c532307..66586a767 100644
--- a/packages/plugins/opentelemetry/src/hive-span-processor.ts
+++ b/packages/plugins/opentelemetry/src/hive-span-processor.ts
@@ -9,11 +9,7 @@ import {
 } from '@opentelemetry/sdk-trace-base';
 import type { SpanImpl } from '@opentelemetry/sdk-trace-base/build/src/Span';
 import { SEMATTRS_HTTP_METHOD } from '@opentelemetry/semantic-conventions';
-import {
-  SEMATTRS_HIVE_GATEWAY_OPERATION_SUBGRAPH_NAMES,
-  SEMATTRS_HIVE_GRAPHQL_ERROR_CODES,
-  SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT,
-} from './attributes';
+import { SEMATTRS_HIVE_GATEWAY_OPERATION_SUBGRAPH_NAMES } from './attributes';
 
 export type HiveTracingSpanProcessorOptions =
   | {
@@ -152,11 +148,6 @@ export class HiveTracingSpanProcessor implements SpanProcessor {
       return;
     }
 
-    if (SPANS_WITH_ERRORS.includes(span.name)) {
-      copyAttribute(span, operationSpan, SEMATTRS_HIVE_GRAPHQL_ERROR_CODES);
-      copyAttribute(span, operationSpan, SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT);
-    }
-
     if (span.name === 'graphql.execute') {
       copyAttribute(
         span,
@@ -208,9 +199,3 @@ function isOperationSpan(span: Span): boolean {
   const followingChar = span.name.at(17);
   return !followingChar || followingChar === ' ';
 }
-
-const SPANS_WITH_ERRORS = [
-  'graphql.parse',
-  'graphql.validate',
-  'graphql.execute',
-];
diff --git a/packages/plugins/opentelemetry/src/plugin.ts b/packages/plugins/opentelemetry/src/plugin.ts
index 6742e0203..03aeb3684 100644
--- a/packages/plugins/opentelemetry/src/plugin.ts
+++ b/packages/plugins/opentelemetry/src/plugin.ts
@@ -6,6 +6,7 @@ import {
   type GatewayPlugin,
 } from '@graphql-hive/gateway-runtime';
 import { getHeadersObj } from '@graphql-mesh/utils';
+import { ExecutionArgs } from '@graphql-tools/executor';
 import { ExecutionRequest, fakePromise } from '@graphql-tools/utils';
 import { unfakePromise } from '@whatwg-node/promise-helpers';
 import {
@@ -36,6 +37,7 @@ import {
   createSchemaLoadingSpan,
   createSubgraphExecuteSpan,
   createUpstreamHttpFetchSpan,
+  isGraphQLError,
   OperationHashingFn,
   recordCacheError,
   recordCacheEvent,
@@ -465,7 +467,9 @@ export function useOpenTelemetry(
           try {
             wrapped();
           } catch (err) {
-            registerException(forOperation.otel!.current, err);
+            if (err instanceof Error && !isGraphQLError(err)) {
+              registerException(forOperation.otel!.current, err);
+            }
             throw err;
           } finally {
             trace.getSpan(forOperation.otel!.current)?.end();
@@ -791,6 +795,7 @@ export function useOpenTelemetry(
         return ({ result }) => {
           setGraphQLParseAttributes({
             ctx: getContext(state),
+            operationCtx: state.forOperation.otel!.root,
             operationName: gqlCtx.params.operationName,
             query: gqlCtx.params.query?.trim(),
             result,
@@ -816,6 +821,7 @@ export function useOpenTelemetry(
         return ({ result }) => {
           setGraphQLValidateAttributes({
             ctx: getContext(state),
+            operationCtx: state.forOperation.otel!.root,
             result,
             document: params.documentAST,
             operationName: gqlCtx.params.operationName,
@@ -832,6 +838,8 @@ export function useOpenTelemetry(
           return;
         }
 
+        (args as ExecutionArgs).schemaCoordinateInErrors = true;
+
         const ctx = getContext(state);
         setGraphQLExecutionAttributes({
           ctx,
@@ -847,6 +855,7 @@ export function useOpenTelemetry(
             setGraphQLExecutionResultAttributes({
               ctx,
               result,
+              operationCtx: state.forOperation.otel!.root,
               subgraphNames: state.forOperation.subgraphNames,
             });
           },
diff --git a/packages/plugins/opentelemetry/src/setup.ts b/packages/plugins/opentelemetry/src/setup.ts
index c39a6421b..46c086467 100644
--- a/packages/plugins/opentelemetry/src/setup.ts
+++ b/packages/plugins/opentelemetry/src/setup.ts
@@ -36,6 +36,7 @@ import {
   ATTR_SERVICE_VERSION,
 } from '@opentelemetry/semantic-conventions';
 import { getEnvBool, getEnvStr } from '~internal/env';
+import { LogLevel } from 'rollup';
 import {
   HiveTracingSpanProcessor,
   HiveTracingSpanProcessorOptions,
@@ -144,7 +145,7 @@ type OpentelemetrySetupOptions = TracingOptions &
      * The Logger to be used by this utility.
      * A child of this logger will be used for OTEL diag API, unless `configureDiagLogger` is false
      */
-    log?: Logger;
+    log?: Logger | false | LogLevel;
     /**
      * Configure Opentelemetry `diag` API to use Gateway's logger.
      *
@@ -157,7 +158,10 @@ type OpentelemetrySetupOptions = TracingOptions &
   };
 
 export function openTelemetrySetup(options: OpentelemetrySetupOptions) {
-  const log = options.log || new Logger();
+  const log =
+    !options.log || typeof options.log === 'string'
+      ? new Logger({ level: options.log })
+      : options.log;
 
   if (getEnvBool('OTEL_SDK_DISABLED')) {
     log.warn(
@@ -303,10 +307,14 @@ export type HiveTracingOptions = { target?: string } & (
 export function hiveTracingSetup(
   config: HiveTracingOptions & {
     contextManager: ContextManager | null;
-    log?: Logger;
+    log?: Logger | false | LogLevel;
   },
 ) {
-  const log = config.log || new Logger();
+  const log =
+    !config.log || typeof config.log === 'string'
+      ? new Logger({ level: config.log })
+      : config.log;
+
   config.target ??= getEnvStr('HIVE_TARGET');
 
   if (!config.target) {
diff --git a/packages/plugins/opentelemetry/src/spans.ts b/packages/plugins/opentelemetry/src/spans.ts
index e550ffaaf..ea0ec17db 100644
--- a/packages/plugins/opentelemetry/src/spans.ts
+++ b/packages/plugins/opentelemetry/src/spans.ts
@@ -3,13 +3,16 @@ import { OnCacheGetHookEventPayload } from '@graphql-hive/gateway-runtime';
 import { defaultPrintFn } from '@graphql-mesh/transport-common';
 import {
   getOperationASTFromDocument,
+  getSchemaCoordinate,
   isAsyncIterable,
   type ExecutionRequest,
   type ExecutionResult,
 } from '@graphql-tools/utils';
 import {
+  Attributes,
   context,
   ROOT_CONTEXT,
+  Span,
   SpanKind,
   SpanStatusCode,
   trace,
@@ -17,12 +20,14 @@ import {
   type Tracer,
 } from '@opentelemetry/api';
 import {
+  ATTR_EXCEPTION_STACKTRACE,
   SEMATTRS_EXCEPTION_MESSAGE,
   SEMATTRS_EXCEPTION_STACKTRACE,
   SEMATTRS_EXCEPTION_TYPE,
 } from '@opentelemetry/semantic-conventions';
 import {
   DocumentNode,
+  GraphQLError,
   GraphQLSchema,
   OperationDefinitionNode,
   printSchema,
@@ -40,8 +45,14 @@ import {
   SEMATTRS_GRAPHQL_OPERATION_TYPE,
   SEMATTRS_HIVE_GATEWAY_OPERATION_SUBGRAPH_NAMES,
   SEMATTRS_HIVE_GATEWAY_UPSTREAM_SUBGRAPH_NAME,
+  SEMATTRS_HIVE_GRAPHQL_ERROR_CODE,
   SEMATTRS_HIVE_GRAPHQL_ERROR_CODES,
   SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT,
+  SEMATTRS_HIVE_GRAPHQL_ERROR_LOCATIONS,
+  SEMATTRS_HIVE_GRAPHQL_ERROR_MESSAGE,
+  SEMATTRS_HIVE_GRAPHQL_ERROR_PATH,
+  SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATE,
+  SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATES,
   SEMATTRS_HIVE_GRAPHQL_OPERATION_HASH,
   SEMATTRS_HTTP_CLIENT_IP,
   SEMATTRS_HTTP_HOST,
@@ -217,6 +228,7 @@ export function createGraphQLParseSpan(input: {
 
 export function setGraphQLParseAttributes(input: {
   ctx: Context;
+  operationCtx: Context;
   query?: string;
   operationName?: string;
   result: unknown;
@@ -231,7 +243,28 @@ export function setGraphQLParseAttributes(input: {
   }
 
   if (input.result instanceof Error) {
-    span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT, 1);
+    if (isGraphQLError(input.result)) {
+      span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT, 1);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: 'GraphQL Parse Error',
+      });
+      const operationSpan = trace.getSpan(input.operationCtx);
+      if (operationSpan) {
+        recordGraphqlErrors(
+          operationSpan,
+          [input.result as GraphQLError],
+          'GraphQL Parse Error',
+        );
+      }
+    } else {
+      // It is a JS Exception
+      span.recordException(input.result);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: input.result.message,
+      });
+    }
   } else {
     // result should be a document
     const document = input.result as DocumentNode;
@@ -262,6 +295,7 @@ export function createGraphQLValidateSpan(input: {
 
 export function setGraphQLValidateAttributes(input: {
   ctx: Context;
+  operationCtx: Context;
   document: DocumentNode;
   operationName: string | undefined | null;
   result: any[] | readonly Error[];
@@ -281,28 +315,45 @@ export function setGraphQLValidateAttributes(input: {
     }
   }
 
-  const errors = Array.isArray(result) ? result : [];
+  const errors: (Error | GraphQLError)[] = Array.isArray(result) ? result : [];
 
   if (result instanceof Error) {
     errors.push(result);
   }
 
-  if (errors.length > 0) {
+  if (errors.length === 0) {
+    return;
+  }
+
+  const graphqlErrors: GraphQLError[] = [];
+  const exceptions: Error[] = [];
+  for (const error of errors) {
+    (isGraphQLError(error) ? graphqlErrors : exceptions).push(error);
+  }
+
+  if (graphqlErrors.length > 0) {
     span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT, result.length);
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: result.map((e) => e.message).join(', '),
-    });
 
-    const codes = [];
-    for (const error of result) {
-      if (error.extensions?.code) {
-        codes.push(`${error.extensions.code}`);
-      }
-      span.recordException(error);
+    const operationSpan = trace.getSpan(input.operationCtx);
+    if (operationSpan) {
+      recordGraphqlErrors(
+        operationSpan,
+        graphqlErrors,
+        'GraphQL Validation Error',
+      );
     }
-    span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_CODES, codes);
   }
+
+  if (exceptions.length > 0) {
+    for (const exception of exceptions) {
+      span.recordException(exception);
+    }
+  }
+
+  span.setStatus({
+    code: SpanStatusCode.ERROR,
+    message: 'GraphQL Validation Error',
+  });
 }
 
 export function createGraphQLExecuteSpan(input: {
@@ -358,43 +409,41 @@ export function setGraphQLExecutionAttributes(input: {
 
 export function setGraphQLExecutionResultAttributes(input: {
   ctx: Context;
+  operationCtx: Context;
   result: ExecutionResult | AsyncIterableIterator<ExecutionResult>;
   subgraphNames?: string[];
 }) {
-  const { ctx, result } = input;
+  const { ctx, operationCtx, result } = input;
+
   const span = trace.getSpan(ctx);
-  if (!span) {
-    return;
+  if (span) {
+    if (input.subgraphNames?.length) {
+      span.setAttribute(
+        SEMATTRS_HIVE_GATEWAY_OPERATION_SUBGRAPH_NAMES,
+        input.subgraphNames,
+      );
+    }
   }
 
-  if (input.subgraphNames?.length) {
-    span.setAttribute(
-      SEMATTRS_HIVE_GATEWAY_OPERATION_SUBGRAPH_NAMES,
-      input.subgraphNames,
-    );
-  }
+  const operationSpan = trace.getSpan(operationCtx);
 
   if (
     !isAsyncIterable(result) && // FIXME: Handle async iterable too
     result.errors &&
     result.errors.length > 0
   ) {
-    span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT, result.errors.length);
-    span.setStatus({
+    span?.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT, result.errors.length);
+    span?.setStatus({
       code: SpanStatusCode.ERROR,
-      message: result.errors.map((e) => e.message).join(', '),
+      message: 'GraphQL Execution Error',
     });
 
-    const codes: string[] = [];
-    for (const error of result.errors) {
-      span.recordException(error);
-      if (error.extensions?.['code']) {
-        codes.push(`${error.extensions['code']}`); // Ensure string using string interpolation
-      }
-    }
-
-    if (codes.length > 0) {
-      span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_CODES, codes);
+    if (operationSpan) {
+      recordGraphqlErrors(
+        operationSpan,
+        result.errors,
+        'GraphQL Execution Error',
+      );
     }
   }
 }
@@ -604,3 +653,90 @@ export const getOperationFromDocument = (
   operationNameMap.set(operationName ?? null, operation);
   return operation;
 };
+
+function recordGraphqlErrors(
+  span: Span,
+  errors: readonly GraphQLError[],
+  message?: string,
+): void {
+  const codes: string[] = [];
+  const schemaCoordinates: string[] = [];
+
+  span.setStatus({
+    code: SpanStatusCode.ERROR,
+    message: message ?? 'GraphQL Error',
+  });
+  span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT, errors.length);
+
+  for (const error of errors) {
+    const attributes = attributesFromGraphqlError(error);
+    if (attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_CODE]) {
+      codes.push(attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_CODE] as string);
+    }
+    if (attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATE]) {
+      schemaCoordinates.push(
+        attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATE] as string,
+      );
+    }
+
+    span.addEvent('graphql.error', attributes);
+  }
+
+  if (codes.length > 0) {
+    span.setAttribute(SEMATTRS_HIVE_GRAPHQL_ERROR_CODES, codes);
+  }
+
+  if (schemaCoordinates.length > 0) {
+    span.setAttribute(
+      SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATES,
+      schemaCoordinates,
+    );
+  }
+}
+
+function attributesFromGraphqlError(error: GraphQLError): Attributes {
+  const attributes: Attributes = {
+    [SEMATTRS_HIVE_GRAPHQL_ERROR_MESSAGE]: error.message,
+  };
+
+  if (error.path) {
+    attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_PATH] = error.path.map((p) =>
+      p.toString(),
+    );
+  }
+
+  if (error.locations) {
+    attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_LOCATIONS] = error.locations.map(
+      ({ line, column }) => `${line}:${column}`,
+    );
+  }
+
+  if (error.extensions) {
+    const code = error.extensions?.['code'];
+    if (code) {
+      const codeStr = `${code}`; // Ensure string using string interpolation
+      attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_CODE] = codeStr;
+    }
+
+    const schemaCoordinate = getSchemaCoordinate(error);
+    if (schemaCoordinate) {
+      attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_SCHEMA_COORDINATE] =
+        schemaCoordinate;
+    }
+
+    const originalError: Error | undefined = error.extensions[
+      'originalError'
+    ] as Error;
+    if (originalError?.stack) {
+      attributes[ATTR_EXCEPTION_STACKTRACE] = originalError.stack;
+    }
+  }
+
+  return attributes;
+}
+
+export function isGraphQLError(error: Error): error is GraphQLError {
+  // It is probably a GraphQLError if there is no name.
+  // We can't use instanceof in case of multiple `graphql` deps.
+  return !error.name || error.name === 'GraphQLError';
+}
diff --git a/packages/plugins/opentelemetry/tests/useOpenTelemetry.spec.ts b/packages/plugins/opentelemetry/tests/useOpenTelemetry.spec.ts
index 81397e598..fe80f17c3 100644
--- a/packages/plugins/opentelemetry/tests/useOpenTelemetry.spec.ts
+++ b/packages/plugins/opentelemetry/tests/useOpenTelemetry.spec.ts
@@ -85,6 +85,7 @@ describe('useOpenTelemetry', () => {
 
     it('should setup OTEL with sain default', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: new AsyncLocalStorageContextManager(),
         traces: {
           exporter: new OTLPTraceExporter(),
@@ -130,6 +131,7 @@ describe('useOpenTelemetry', () => {
       };
 
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           tracerProvider,
@@ -143,6 +145,7 @@ describe('useOpenTelemetry', () => {
       const before = getContextManager();
 
       openTelemetrySetup({
+        log: false,
         contextManager: null,
       });
 
@@ -151,6 +154,7 @@ describe('useOpenTelemetry', () => {
 
     it('should register a console exporter', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           console: true,
@@ -166,6 +170,7 @@ describe('useOpenTelemetry', () => {
 
     it('should register a console exporter even if an exporter is given', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           exporter: new OTLPTraceExporter(),
@@ -182,6 +187,7 @@ describe('useOpenTelemetry', () => {
 
     it('should register a console exporter even if a list of processors is given', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           processors: [new SimpleSpanProcessor(new OTLPTraceExporter())],
@@ -198,6 +204,7 @@ describe('useOpenTelemetry', () => {
 
     it('should register a custom resource', () => {
       openTelemetrySetup({
+        log: false,
         resource: resourceFromAttributes({
           'service.name': 'test-name',
           'service.version': 'test-version',
@@ -223,6 +230,7 @@ describe('useOpenTelemetry', () => {
         vi.stubEnv('OTEL_SERVICE_VERSION', 'test-version');
 
         openTelemetrySetup({
+          log: false,
           traces: { console: true },
           contextManager: null,
         });
@@ -238,6 +246,7 @@ describe('useOpenTelemetry', () => {
 
     it('should allow to register a custom sampler', () => {
       openTelemetrySetup({
+        log: false,
         traces: {
           console: true,
         },
@@ -250,6 +259,7 @@ describe('useOpenTelemetry', () => {
 
     it('should allow to configure a rate sampling strategy', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: { console: true },
         samplingRate: 0.1,
@@ -269,6 +279,7 @@ describe('useOpenTelemetry', () => {
 
     it('should allow to disable batching', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           exporter: new OTLPTraceExporter(),
@@ -282,6 +293,7 @@ describe('useOpenTelemetry', () => {
 
     it('should allow to configure batching', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           exporter: new OTLPTraceExporter(),
@@ -307,6 +319,7 @@ describe('useOpenTelemetry', () => {
     it('should allow to manually define processor', () => {
       const processor = {} as SpanProcessor;
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           processors: [processor],
@@ -321,6 +334,7 @@ describe('useOpenTelemetry', () => {
     it('should allow to customize propagators', () => {
       const propagator = {} as TextMapPropagator;
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         propagators: [propagator],
       });
@@ -332,6 +346,7 @@ describe('useOpenTelemetry', () => {
       const before = getPropagator();
 
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         propagators: [],
       });
@@ -341,6 +356,7 @@ describe('useOpenTelemetry', () => {
 
     it('should allow to customize limits', () => {
       openTelemetrySetup({
+        log: false,
         contextManager: null,
         traces: {
           console: true,
@@ -379,6 +395,7 @@ describe('useOpenTelemetry', () => {
 
     it('should setup Hive Tracing', () => {
       hiveTracingSetup({
+        log: false,
         contextManager: new AsyncLocalStorageContextManager(),
         target: 'target',
         accessToken: 'access-token',
@@ -556,7 +573,6 @@ describe('useOpenTelemetry', () => {
           let attempts = 0;
           await using gateway = await buildTestGatewayForCtx({
             gatewayOptions: {
-              logging: true,
               upstreamRetry: {
                 maxRetries: 2,
                 retryDelay: 1,
@@ -769,42 +785,274 @@ describe('useOpenTelemetry', () => {
         });
       });
 
-      it('should handle validation error with hive processor', async () => {
-        disableAll();
-        const traceProvider = new BasicTracerProvider({
-          spanProcessors: [
-            new HiveTracingSpanProcessor({
-              processor: new SimpleSpanProcessor(spanExporter),
-            }),
-          ],
+      describe('error reporting', () => {
+        it('should report execution errors on operation span', async () => {
+          await using gateway = await buildTestGatewayForCtx({
+            fetch: () => async () =>
+              new Response(
+                JSON.stringify({
+                  data: null,
+                  errors: [
+                    {
+                      message: 'Test Error',
+                      path: ['hello'],
+                      extensions: { code: 'TEST_ERROR' },
+                    },
+                  ],
+                }),
+              ),
+          });
+          await gateway.query({ shouldReturnErrors: true });
+
+          const operationSpan = spanExporter.assertRoot('graphql.operation');
+          expect(operationSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Execution Error',
+          });
+          expect(operationSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+            'hive.graphql.error.codes': ['TEST_ERROR'],
+            'hive.graphql.error.coordinates': ['Query.hello'],
+          });
+
+          const executionSpan = operationSpan.expectChild('graphql.execute');
+          expect(executionSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Execution Error',
+          });
+          expect(executionSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const errorEvent = operationSpan.span.events.find(
+            (event) => event.name === 'graphql.error',
+          );
+
+          expect(errorEvent?.attributes).toMatchObject({
+            'hive.graphql.error.path': ['hello'],
+            'hive.graphql.error.message': 'Test Error',
+            'hive.graphql.error.code': 'TEST_ERROR',
+            'hive.graphql.error.coordinate': 'Query.hello',
+          });
         });
-        setupOtelForTests({ traceProvider });
-        await using gateway = await buildTestGatewayForCtx({
-          plugins: ({ fetch }) => {
-            return [
-              {
-                onPluginInit() {
-                  fetch('http://foo.bar', {});
-                },
-              },
-            ];
-          },
+
+        it('should report validation errors on operation span', async () => {
+          await using gateway = await buildTestGatewayForCtx();
+          await gateway.query({
+            shouldReturnErrors: true,
+            body: { query: 'query test { unknown }' },
+          });
+
+          const operationSpan = spanExporter.assertRoot(
+            'graphql.operation test',
+          );
+          expect(operationSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Validation Error',
+          });
+          expect(operationSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+            'graphql.operation.type': 'query',
+            'graphql.operation.name': 'test',
+          });
+
+          const validateSpan = operationSpan.expectChild('graphql.validate');
+          expect(validateSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Validation Error',
+          });
+          expect(validateSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const errorEvent = operationSpan.span.events.find(
+            (event) => event.name === 'graphql.error',
+          );
+
+          expect(errorEvent?.attributes).toMatchObject({
+            'hive.graphql.error.locations': ['1:14'],
+            'hive.graphql.error.message':
+              'Cannot query field "unknown" on type "Query".',
+          });
         });
-        await gateway.query({
-          body: { query: 'query test{ unknown }' },
-          shouldReturnErrors: true,
+
+        it('should report parsing errors on operation span', async () => {
+          await using gateway = await buildTestGatewayForCtx();
+          await gateway.query({
+            shouldReturnErrors: true,
+            body: { query: 'parse error' },
+          });
+
+          const operationSpan = spanExporter.assertRoot('graphql.operation');
+          expect(operationSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Parse Error',
+          });
+          expect(operationSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const parseSpan = operationSpan.expectChild('graphql.parse');
+          expect(parseSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Parse Error',
+          });
+          expect(parseSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const errorEvent = operationSpan.span.events.find(
+            (event) => event.name === 'graphql.error',
+          );
+
+          expect(errorEvent?.attributes).toMatchObject({
+            'hive.graphql.error.locations': ['1:1'],
+            'hive.graphql.error.message':
+              'Syntax Error: Unexpected Name "parse".',
+          });
         });
 
-        const operationSpan = spanExporter.assertRoot('graphql.operation test');
-        expect(operationSpan.span.attributes['graphql.operation.name']).toBe(
-          'test',
-        );
-        expect(operationSpan.span.attributes['graphql.operation.type']).toBe(
-          'query',
-        );
-        expect(
-          operationSpan.span.attributes[SEMATTRS_HIVE_GRAPHQL_ERROR_COUNT],
-        ).toBe(1);
+        describe('hive processor', () => {
+          it('should handle validation error with hive processor', async () => {
+            disableAll();
+            const traceProvider = new BasicTracerProvider({
+              spanProcessors: [
+                new HiveTracingSpanProcessor({
+                  processor: new SimpleSpanProcessor(spanExporter),
+                }),
+              ],
+            });
+            setupOtelForTests({ traceProvider });
+            await using gateway = await buildTestGatewayForCtx({
+              plugins: ({ fetch }) => {
+                return [
+                  {
+                    onPluginInit() {
+                      fetch('http://foo.bar', {});
+                    },
+                  },
+                ];
+              },
+            });
+            await gateway.query({
+              body: { query: 'query test { unknown }' },
+              shouldReturnErrors: true,
+            });
+
+            const operationSpan = spanExporter.assertRoot(
+              'graphql.operation test',
+            );
+
+            expect(operationSpan.span.status).toMatchObject({
+              code: SpanStatusCode.ERROR,
+              message: 'GraphQL Validation Error',
+            });
+
+            expect(operationSpan.span.attributes).toMatchObject({
+              'graphql.operation.name': 'test',
+              'graphql.operation.type': 'query',
+              'hive.graphql.error.count': 1,
+            });
+
+            const errorEvent = operationSpan.span.events.find(
+              (event) => event.name === 'graphql.error',
+            );
+
+            expect(errorEvent?.attributes).toMatchObject({
+              'hive.graphql.error.locations': ['1:14'],
+              'hive.graphql.error.message':
+                'Cannot query field "unknown" on type "Query".',
+            });
+          });
+
+          it('should handle parsing error with hive processor', async () => {
+            disableAll();
+            const traceProvider = new BasicTracerProvider({
+              spanProcessors: [
+                new HiveTracingSpanProcessor({
+                  processor: new SimpleSpanProcessor(spanExporter),
+                }),
+              ],
+            });
+            setupOtelForTests({ traceProvider });
+            await using gateway = await buildTestGatewayForCtx();
+            await gateway.query({
+              body: { query: 'parse error' },
+              shouldReturnErrors: true,
+            });
+
+            const operationSpan = spanExporter.assertRoot('graphql.operation');
+            expect(operationSpan.span.status).toMatchObject({
+              code: SpanStatusCode.ERROR,
+              message: 'GraphQL Parse Error',
+            });
+            expect(operationSpan.span.attributes).toMatchObject({
+              'hive.graphql.error.count': 1,
+            });
+
+            const errorEvent = operationSpan.span.events.find(
+              (event) => event.name === 'graphql.error',
+            );
+
+            expect(errorEvent?.attributes).toMatchObject({
+              'hive.graphql.error.locations': ['1:1'],
+              'hive.graphql.error.message':
+                'Syntax Error: Unexpected Name "parse".',
+            });
+          });
+
+          it('should handle execute error with hive processor', async () => {
+            disableAll();
+            const traceProvider = new BasicTracerProvider({
+              spanProcessors: [
+                new HiveTracingSpanProcessor({
+                  processor: new SimpleSpanProcessor(spanExporter),
+                }),
+              ],
+            });
+            setupOtelForTests({ traceProvider });
+            await using gateway = await buildTestGatewayForCtx({
+              fetch: () => async () =>
+                new Response(
+                  JSON.stringify({
+                    data: null,
+                    errors: [
+                      {
+                        message: 'Test Error',
+                        path: ['hello'],
+                        extensions: { code: 'TEST_ERROR' },
+                      },
+                    ],
+                  }),
+                ),
+            });
+            await gateway.query({
+              shouldReturnErrors: true,
+            });
+
+            const operationSpan = spanExporter.assertRoot('graphql.operation');
+            expect(operationSpan.span.status).toMatchObject({
+              code: SpanStatusCode.ERROR,
+              message: 'GraphQL Execution Error',
+            });
+            expect(operationSpan.span.attributes).toMatchObject({
+              'hive.graphql.error.count': 1,
+              'hive.graphql.error.codes': ['TEST_ERROR'],
+              'hive.graphql.error.coordinates': ['Query.hello'],
+            });
+
+            const errorEvent = operationSpan.span.events.find(
+              (event) => event.name === 'graphql.error',
+            );
+
+            expect(errorEvent?.attributes).toMatchObject({
+              'hive.graphql.error.path': ['hello'],
+              'hive.graphql.error.message': 'Test Error',
+              'hive.graphql.error.code': 'TEST_ERROR',
+              'hive.graphql.error.coordinate': 'Query.hello',
+            });
+          });
+        });
       });
     });
 
@@ -1182,6 +1430,7 @@ describe('useOpenTelemetry', () => {
       // Register testing OTEL api with a custom Span processor and an Async Context Manager
       disableAll();
       hiveTracingSetup({
+        log: false,
         target: 'test-target',
         contextManager: new AsyncLocalStorageContextManager(),
         processor: new SimpleSpanProcessor(spanExporter),
@@ -1195,7 +1444,7 @@ describe('useOpenTelemetry', () => {
       spanExporter.assertNoSpanWithName('POST /graphql');
     });
 
-    it('should have all attributes required by Hive Tracing', async () => {
+    it.skip('should have all attributes required by Hive Tracing', async () => {
       await using gateway = await buildTestGateway({
         fetch: () => () => new Response(null, { status: 500 }),
       });
diff --git a/packages/plugins/opentelemetry/tests/yoga.spec.ts b/packages/plugins/opentelemetry/tests/yoga.spec.ts
index 9331c6ad3..5b5c4a3f9 100644
--- a/packages/plugins/opentelemetry/tests/yoga.spec.ts
+++ b/packages/plugins/opentelemetry/tests/yoga.spec.ts
@@ -1,7 +1,12 @@
 import { Logger } from '@graphql-hive/logger';
-import { createSchema, createYoga, Plugin as YogaPlugin } from 'graphql-yoga';
+import {
+  createGraphQLError,
+  createSchema,
+  createYoga,
+  Plugin as YogaPlugin,
+} from 'graphql-yoga';
 import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { hive } from '../src/api';
+import { hive, SpanStatusCode } from '../src/api';
 import { ContextMatcher, useOpenTelemetry } from '../src/plugin';
 import { disableAll, setupOtelForTests, spanExporter } from './utils';
 
@@ -31,11 +36,27 @@ describe('useOpenTelemetry', () => {
             typeDefs: /* GraphQL */ `
               type Query {
                 hello: String
+                withFailing: WithFailing
+              }
+
+              type WithFailing {
+                failingField: String
               }
             `,
             resolvers: {
               Query: {
                 hello: () => 'World',
+                withFailing: () => ({}),
+              },
+              WithFailing: {
+                failingField: () => {
+                  throw createGraphQLError('Test', {
+                    extensions: {
+                      code: 'TEST',
+                      originalError: new Error('Test'),
+                    },
+                  });
+                },
               },
             },
           }),
@@ -51,20 +72,32 @@ describe('useOpenTelemetry', () => {
         });
 
         return {
-          query: async () => {
+          query: async (
+            queryOptions: {
+              query?: string;
+              shouldError?: boolean;
+            } = {},
+          ) => {
             const response = await yoga.fetch('http://yoga/graphql', {
               method: 'POST',
               headers: {
                 'content-type': 'application/json',
               },
-              body: JSON.stringify({ query: '{ hello }' }),
+              body: JSON.stringify({
+                query: queryOptions.query ?? '{ hello }',
+              }),
             });
             expect(response.status).toBe(200);
             const result = await response.json();
-            if (result.errors) {
-              console.error('Graphql Errors:', result.errors);
+            if (queryOptions.shouldError) {
+              expect(result.errors?.length).toBeGreaterThan(0);
+            } else {
+              if (result.errors) {
+                console.error('Graphql Errors:', result.errors);
+              }
+              expect(result.errors).not.toBeDefined();
             }
-            expect(result.errors).not.toBeDefined();
+            return result;
           },
           [Symbol.asyncDispose]: async () => {
             await yoga.dispose();
@@ -142,6 +175,127 @@ describe('useOpenTelemetry', () => {
           }
         });
       });
+
+      describe('error reporting', () => {
+        it('should report execution errors on operation span', async () => {
+          await using gateway = buildTest();
+          await gateway.query({
+            query: '{ withFailing { failingField } }',
+            shouldError: true,
+          });
+
+          const operationSpan = spanExporter.assertRoot('graphql.operation');
+          expect(operationSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Execution Error',
+          });
+          expect(operationSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+            'hive.graphql.error.codes': ['TEST'],
+            'hive.graphql.error.coordinates': ['WithFailing.failingField'],
+          });
+
+          const executionSpan = operationSpan.expectChild('graphql.execute');
+          expect(executionSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Execution Error',
+          });
+          expect(executionSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const errorEvent = operationSpan.span.events.find(
+            (event) => event.name === 'graphql.error',
+          );
+
+          expect(errorEvent?.attributes).toMatchObject({
+            'hive.graphql.error.message': 'Test',
+            'hive.graphql.error.code': 'TEST',
+            'hive.graphql.error.path': ['withFailing', 'failingField'],
+            'hive.graphql.error.locations': ['1:17'],
+            'hive.graphql.error.coordinate': 'WithFailing.failingField',
+          });
+          expect(errorEvent?.attributes?.['exception.stacktrace']).toMatch(
+            /^Error: Test\n/,
+          );
+        });
+
+        it('should report validation errors on operation span', async () => {
+          await using gateway = buildTest();
+          await gateway.query({
+            query: 'query test { unknown }',
+            shouldError: true,
+          });
+
+          const operationSpan = spanExporter.assertRoot(
+            'graphql.operation test',
+          );
+          expect(operationSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Validation Error',
+          });
+          expect(operationSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+            'graphql.operation.type': 'query',
+            'graphql.operation.name': 'test',
+          });
+
+          const validateSpan = operationSpan.expectChild('graphql.validate');
+          expect(validateSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Validation Error',
+          });
+          expect(validateSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const errorEvent = operationSpan.span.events.find(
+            (event) => event.name === 'graphql.error',
+          );
+
+          expect(errorEvent?.attributes).toMatchObject({
+            'hive.graphql.error.locations': ['1:14'],
+            'hive.graphql.error.message':
+              'Cannot query field "unknown" on type "Query".',
+          });
+        });
+
+        it('should report parsing errors on operation span', async () => {
+          await using gateway = buildTest();
+          await gateway.query({
+            query: 'parse error',
+            shouldError: true,
+          });
+
+          const operationSpan = spanExporter.assertRoot('graphql.operation');
+          expect(operationSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Parse Error',
+          });
+          expect(operationSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const parseSpan = operationSpan.expectChild('graphql.parse');
+          expect(parseSpan.span.status).toMatchObject({
+            code: SpanStatusCode.ERROR,
+            message: 'GraphQL Parse Error',
+          });
+          expect(parseSpan.span.attributes).toMatchObject({
+            'hive.graphql.error.count': 1,
+          });
+
+          const errorEvent = operationSpan.span.events.find(
+            (event) => event.name === 'graphql.error',
+          );
+
+          expect(errorEvent?.attributes).toMatchObject({
+            'hive.graphql.error.locations': ['1:1'],
+            'hive.graphql.error.message':
+              'Syntax Error: Unexpected Name "parse".',
+          });
+        });
+      });
     });
   });
 });
diff --git a/packages/runtime/src/utils.ts b/packages/runtime/src/utils.ts
index 51b7d0dc7..1e6e56a93 100644
--- a/packages/runtime/src/utils.ts
+++ b/packages/runtime/src/utils.ts
@@ -104,6 +104,7 @@ export const getExecuteFnFromExecutor = memoize1(
         rootValue: args.rootValue,
         context: args.contextValue,
         signal: args.signal,
+        schemaCoordinateInErrors: args.schemaCoordinateInErrors,
       });
     };
   },
diff --git a/packages/signal/src/abortSignalAll.ts b/packages/signal/src/abortSignalAll.ts
new file mode 100644
index 000000000..15e6bbc38
--- /dev/null
+++ b/packages/signal/src/abortSignalAll.ts
@@ -0,0 +1,105 @@
+// Some runtimes doesn't implement FinalizationRegistry. For those, we don't handle GC of signals
+// and only rely on signal abortion. It is ok because most of the time they are short live runtime,
+// and it's any just an optimization. It will not break the resolution, only miss or delay abortion.
+const allSignalRegistry = globalThis.FinalizationRegistry
+  ? new FinalizationRegistry<() => void>((cb) => cb())
+  : null;
+
+const controllerInSignalSy = Symbol('CONTROLLER_IN_SIGNAL');
+
+/**
+ * Memory safe AbortSignal merger.
+ * The resulting signal is aborted once all signals have aborted or GCed.
+ */
+export function abortSignalAll(
+  signals: AbortSignal[],
+): AbortSignal | undefined {
+  if (signals.length === 0) {
+    // if no signals are passed, return undefined because the abortcontroller
+    // wouldnt ever be aborted (should be when GCd, but it's only a waste of memory)
+    // furthermore, the native AbortSignal.any will also never abort if receiving no signals
+    return undefined;
+  }
+
+  if (signals.length === 1) {
+    // no need to waste resources by wrapping a single signal, simply return it
+    return signals[0];
+  }
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      // if any of the signals has already been aborted, return it immediately no need to continue at all
+      return signal;
+    }
+  }
+
+  // we use weak refs for both the root controller and the passed signals
+  // because we want to make sure that signals are aborted and disposed of
+  // in both cases when GC-ed and actually aborted
+
+  const ctrl = new AbortController();
+  const ctrlRef = new WeakRef(ctrl);
+
+  const eventListenerPairs: [WeakRef<AbortSignal>, () => void][] = [];
+  let retainedSignalsCount = signals.length;
+
+  function removeSignal(signal: AbortSignal, abortListener: () => void) {
+    signal.removeEventListener('abort', abortListener);
+    allSignalRegistry?.unregister(signal);
+    --retainedSignalsCount;
+  }
+
+  for (const signal of signals) {
+    const signalRef = new WeakRef(signal);
+    function onAbort() {
+      const signal = signalRef.deref();
+      if (signal) {
+        removeSignal(signal, onAbort);
+        // abort when all of the signals have been GCed or aborted
+        if (retainedSignalsCount === 0) {
+          ctrlRef.deref()?.abort(signal.reason);
+        }
+      }
+    }
+    signal.addEventListener('abort', onAbort);
+    eventListenerPairs.push([signalRef, onAbort]);
+    allSignalRegistry?.register(
+      signal,
+      () => {
+        removeSignal(signal, onAbort);
+        // dispose when all of the signals have been GCed
+        if (retainedSignalsCount === 0) {
+          dispose();
+        }
+      },
+      signal,
+    );
+  }
+
+  function dispose() {
+    const ctrl = ctrlRef.deref();
+    if (ctrl) {
+      allSignalRegistry?.unregister(ctrl.signal);
+      // @ts-expect-error
+      delete ctrl.signal[controllerInSignalSy];
+    }
+
+    for (const [signalRef, onAbort] of eventListenerPairs) {
+      const signal = signalRef.deref();
+      if (signal) {
+        removeSignal(signal, onAbort);
+      }
+    }
+  }
+
+  // cleanup when aborted
+  ctrl.signal.addEventListener('abort', dispose);
+  // cleanup when GCed
+  allSignalRegistry?.register(ctrl.signal, dispose, ctrl.signal);
+
+  // keeping a strong reference of the controller binding it to the lifecycle of its signal
+  // @ts-expect-error
+  ctrl.signal[controllerInSignalSy] = ctrl;
+
+  return ctrl.signal;
+}
diff --git a/packages/signal/tests/abortSignalAll.test.ts b/packages/signal/tests/abortSignalAll.test.ts
new file mode 100644
index 000000000..035ddd83d
--- /dev/null
+++ b/packages/signal/tests/abortSignalAll.test.ts
@@ -0,0 +1,158 @@
+import LeakDetector from 'jest-leak-detector';
+import { describe, expect, it } from 'vitest';
+import { abortSignalAll } from '../src/abortSignalAll';
+
+describe.skipIf(
+  // doesn't report leaks locally, but does in the CI.
+  // we confirm that there is no leaks directly in tests below
+  // TODO: investigate why
+  process.env['LEAK_TEST'],
+)('abortSignalAll', () => {
+  it('should return the single signal passed', () => {
+    const ctrl = new AbortController();
+
+    const signal = abortSignalAll([ctrl.signal]);
+
+    expect(ctrl.signal).toBe(signal);
+  });
+
+  it('should return undefined if no signals have been passed', () => {
+    const signal = abortSignalAll([]);
+
+    expect(signal).toBeUndefined();
+  });
+
+  it('should not abort if none of the signals abort', () => {
+    const ctrl1 = new AbortController();
+    const ctrl2 = new AbortController();
+
+    const signal = abortSignalAll([ctrl1.signal, ctrl2.signal]);
+
+    expect(() => signal!.throwIfAborted()).not.toThrow();
+  });
+
+  it('should not abort if only some signal aborts', async () => {
+    const ctrl1 = new AbortController();
+    const ctrl2 = new AbortController();
+
+    const signal = abortSignalAll([ctrl1.signal, ctrl2.signal]);
+    ctrl1.abort('Test');
+
+    expect(signal).not.toBe(ctrl1.signal);
+
+    expect(() => signal!.throwIfAborted()).not.toThrow('Test');
+  });
+
+  it('should abort if all signal aborts', async () => {
+    const ctrl1 = new AbortController();
+    const ctrl2 = new AbortController();
+
+    const signal = abortSignalAll([ctrl1.signal, ctrl2.signal]);
+    ctrl1.abort('Test');
+    ctrl2.abort('Test');
+
+    expect(signal).not.toBe(ctrl1.signal);
+
+    expect(() => signal!.throwIfAborted()).toThrow('Test');
+  });
+
+  it('should return aborted signal if aborted before any', () => {
+    const ctrl1 = new AbortController();
+    const ctrl2 = new AbortController();
+
+    ctrl1.abort('Test');
+    ctrl2.abort('Test');
+    const signal = abortSignalAll([ctrl1.signal, ctrl2.signal]);
+
+    expect(signal).toBe(ctrl1.signal);
+
+    expect(() => signal!.throwIfAborted()).toThrow('Test');
+  });
+
+  it.skipIf(!!global.Bun)('should GC all signals after abort', async () => {
+    let ctrl1: AbortController | undefined = new AbortController();
+    const ctrl1Detector = new LeakDetector(ctrl1);
+    const ctrl1SignalDetector = new LeakDetector(ctrl1.signal);
+    let ctrl2: AbortController | undefined = new AbortController();
+    const ctrl2Detector = new LeakDetector(ctrl2);
+    const ctrl2SignalDetector = new LeakDetector(ctrl2.signal);
+
+    let signal: AbortSignal | undefined = abortSignalAll([
+      ctrl1.signal,
+      ctrl2.signal,
+    ]);
+    const signalDetector = new LeakDetector(signal);
+
+    ctrl1.abort('Test');
+    ctrl2.abort('Test');
+
+    expect(() => signal!.throwIfAborted()).toThrow('Test');
+
+    ctrl1 = undefined;
+    ctrl2 = undefined;
+    signal = undefined;
+
+    await expect(ctrl1Detector.isLeaking()).resolves.toBeFalsy();
+    await expect(ctrl1SignalDetector.isLeaking()).resolves.toBeFalsy();
+    await expect(ctrl2Detector.isLeaking()).resolves.toBeFalsy();
+    await expect(ctrl2SignalDetector.isLeaking()).resolves.toBeFalsy();
+    await expect(signalDetector.isLeaking()).resolves.toBeFalsy();
+  });
+
+  it.skipIf(!!global.Bun)('should GC all signals without abort', async () => {
+    let ctrl1: AbortController | undefined = new AbortController();
+    const ctrl1Detector = new LeakDetector(ctrl1);
+    const ctrl1SignalDetector = new LeakDetector(ctrl1.signal);
+    let ctrl2: AbortController | undefined = new AbortController();
+    const ctrl2Detector = new LeakDetector(ctrl2);
+    const ctrl2SignalDetector = new LeakDetector(ctrl2.signal);
+
+    let signal: AbortSignal | undefined = abortSignalAll([
+      ctrl1.signal,
+      ctrl2.signal,
+    ]);
+    const signalDetector = new LeakDetector(signal);
+
+    // no abort
+    // ctrl1.abort('Test');
+
+    ctrl1 = undefined;
+    ctrl2 = undefined;
+    signal = undefined;
+
+    await expect(ctrl1Detector.isLeaking()).resolves.toBeFalsy();
+    await expect(ctrl1SignalDetector.isLeaking()).resolves.toBeFalsy();
+    await expect(ctrl2Detector.isLeaking()).resolves.toBeFalsy();
+    await expect(ctrl2SignalDetector.isLeaking()).resolves.toBeFalsy();
+    await expect(signalDetector.isLeaking()).resolves.toBeFalsy();
+  });
+
+  it.skipIf(!!global.Bun)(
+    'should GC timeout signals without abort',
+    async () => {
+      let ctrl1: AbortController | undefined = new AbortController();
+      const ctrl1Detector = new LeakDetector(ctrl1);
+      const ctrl1SignalDetector = new LeakDetector(ctrl1.signal);
+      let timeoutSignal: AbortSignal | undefined = AbortSignal.timeout(60_000); // longer than the test
+      const timeoutSignalDetector = new LeakDetector(timeoutSignal);
+
+      let signal: AbortSignal | undefined = abortSignalAll([
+        ctrl1.signal,
+        timeoutSignal,
+      ]);
+      const signalDetector = new LeakDetector(signal);
+
+      // no abort
+      // ctrl1.abort('Test');
+
+      ctrl1 = undefined;
+      timeoutSignal = undefined;
+      signal = undefined;
+
+      await expect(ctrl1Detector.isLeaking()).resolves.toBeFalsy();
+      await expect(ctrl1SignalDetector.isLeaking()).resolves.toBeFalsy();
+      await expect(timeoutSignalDetector.isLeaking()).resolves.toBeFalsy();
+      await expect(signalDetector.isLeaking()).resolves.toBeFalsy();
+    },
+  );
+});
diff --git a/yarn.lock b/yarn.lock
index 73ca0c92a..393701017 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1040,14 +1040,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/compat-data@npm:^7.27.2, @babel/compat-data@npm:^7.27.7":
-  version: 7.28.0
-  resolution: "@babel/compat-data@npm:7.28.0"
-  checksum: 10c0/c4e527302bcd61052423f757355a71c3bc62362bac13f7f130de16e439716f66091ff5bdecda418e8fa0271d4c725f860f0ee23ab7bf6e769f7a8bb16dfcb531
-  languageName: node
-  linkType: hard
-
-"@babel/compat-data@npm:^7.28.5":
+"@babel/compat-data@npm:^7.27.2, @babel/compat-data@npm:^7.27.7, @babel/compat-data@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/compat-data@npm:7.28.5"
   checksum: 10c0/702a25de73087b0eba325c1d10979eed7c9b6662677386ba7b5aa6eace0fc0676f78343bae080a0176ae26f58bd5535d73b9d0fbb547fef377692e8b249353a7
@@ -1100,29 +1093,29 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/generator@npm:^7.26.2, @babel/generator@npm:^7.27.5, @babel/generator@npm:^7.28.3":
-  version: 7.28.3
-  resolution: "@babel/generator@npm:7.28.3"
+"@babel/generator@npm:^7.26.2, @babel/generator@npm:^7.27.5, @babel/generator@npm:^7.28.5":
+  version: 7.28.5
+  resolution: "@babel/generator@npm:7.28.5"
   dependencies:
-    "@babel/parser": "npm:^7.28.3"
-    "@babel/types": "npm:^7.28.2"
+    "@babel/parser": "npm:^7.28.5"
+    "@babel/types": "npm:^7.28.5"
     "@jridgewell/gen-mapping": "npm:^0.3.12"
     "@jridgewell/trace-mapping": "npm:^0.3.28"
     jsesc: "npm:^3.0.2"
-  checksum: 10c0/0ff58bcf04f8803dcc29479b547b43b9b0b828ec1ee0668e92d79f9e90f388c28589056637c5ff2fd7bcf8d153c990d29c448d449d852bf9d1bc64753ca462bc
+  checksum: 10c0/9f219fe1d5431b6919f1a5c60db8d5d34fe546c0d8f5a8511b32f847569234ffc8032beb9e7404649a143f54e15224ecb53a3d11b6bb85c3203e573d91fca752
   languageName: node
   linkType: hard
 
-"@babel/generator@npm:^7.28.5":
-  version: 7.28.5
-  resolution: "@babel/generator@npm:7.28.5"
+"@babel/generator@npm:^7.28.3":
+  version: 7.28.3
+  resolution: "@babel/generator@npm:7.28.3"
   dependencies:
-    "@babel/parser": "npm:^7.28.5"
-    "@babel/types": "npm:^7.28.5"
+    "@babel/parser": "npm:^7.28.3"
+    "@babel/types": "npm:^7.28.2"
     "@jridgewell/gen-mapping": "npm:^0.3.12"
     "@jridgewell/trace-mapping": "npm:^0.3.28"
     jsesc: "npm:^3.0.2"
-  checksum: 10c0/9f219fe1d5431b6919f1a5c60db8d5d34fe546c0d8f5a8511b32f847569234ffc8032beb9e7404649a143f54e15224ecb53a3d11b6bb85c3203e573d91fca752
+  checksum: 10c0/0ff58bcf04f8803dcc29479b547b43b9b0b828ec1ee0668e92d79f9e90f388c28589056637c5ff2fd7bcf8d153c990d29c448d449d852bf9d1bc64753ca462bc
   languageName: node
   linkType: hard
 
@@ -1148,24 +1141,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-create-class-features-plugin@npm:^7.27.1, @babel/helper-create-class-features-plugin@npm:^7.28.3":
-  version: 7.28.3
-  resolution: "@babel/helper-create-class-features-plugin@npm:7.28.3"
-  dependencies:
-    "@babel/helper-annotate-as-pure": "npm:^7.27.3"
-    "@babel/helper-member-expression-to-functions": "npm:^7.27.1"
-    "@babel/helper-optimise-call-expression": "npm:^7.27.1"
-    "@babel/helper-replace-supers": "npm:^7.27.1"
-    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.27.1"
-    "@babel/traverse": "npm:^7.28.3"
-    semver: "npm:^6.3.1"
-  peerDependencies:
-    "@babel/core": ^7.0.0
-  checksum: 10c0/f1ace9476d581929128fd4afc29783bb674663898577b2e48ed139cfd2e92dfc69654cff76cb8fd26fece6286f66a99a993186c1e0a3e17b703b352d0bcd1ca4
-  languageName: node
-  linkType: hard
-
-"@babel/helper-create-class-features-plugin@npm:^7.28.5":
+"@babel/helper-create-class-features-plugin@npm:^7.27.1, @babel/helper-create-class-features-plugin@npm:^7.28.3, @babel/helper-create-class-features-plugin@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/helper-create-class-features-plugin@npm:7.28.5"
   dependencies:
@@ -1217,17 +1193,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-member-expression-to-functions@npm:^7.27.1":
-  version: 7.27.1
-  resolution: "@babel/helper-member-expression-to-functions@npm:7.27.1"
-  dependencies:
-    "@babel/traverse": "npm:^7.27.1"
-    "@babel/types": "npm:^7.27.1"
-  checksum: 10c0/5762ad009b6a3d8b0e6e79ff6011b3b8fdda0fefad56cfa8bfbe6aa02d5a8a8a9680a45748fe3ac47e735a03d2d88c0a676e3f9f59f20ae9fadcc8d51ccd5a53
-  languageName: node
-  linkType: hard
-
-"@babel/helper-member-expression-to-functions@npm:^7.28.5":
+"@babel/helper-member-expression-to-functions@npm:^7.27.1, @babel/helper-member-expression-to-functions@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/helper-member-expression-to-functions@npm:7.28.5"
   dependencies:
@@ -1319,14 +1285,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-validator-identifier@npm:^7.27.1":
-  version: 7.27.1
-  resolution: "@babel/helper-validator-identifier@npm:7.27.1"
-  checksum: 10c0/c558f11c4871d526498e49d07a84752d1800bf72ac0d3dad100309a2eaba24efbf56ea59af5137ff15e3a00280ebe588560534b0e894a4750f8b1411d8f78b84
-  languageName: node
-  linkType: hard
-
-"@babel/helper-validator-identifier@npm:^7.28.5":
+"@babel/helper-validator-identifier@npm:^7.27.1, @babel/helper-validator-identifier@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/helper-validator-identifier@npm:7.28.5"
   checksum: 10c0/42aaebed91f739a41f3d80b72752d1f95fd7c72394e8e4bd7cdd88817e0774d80a432451bcba17c2c642c257c483bf1d409dd4548883429ea9493a3bc4ab0847
@@ -1361,25 +1320,25 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.9, @babel/parser@npm:^7.24.7, @babel/parser@npm:^7.26.10, @babel/parser@npm:^7.26.2, @babel/parser@npm:^7.27.2, @babel/parser@npm:^7.28.3, @babel/parser@npm:^7.28.4":
-  version: 7.28.4
-  resolution: "@babel/parser@npm:7.28.4"
+"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.9, @babel/parser@npm:^7.24.7, @babel/parser@npm:^7.26.10, @babel/parser@npm:^7.26.2, @babel/parser@npm:^7.27.2, @babel/parser@npm:^7.28.5":
+  version: 7.28.5
+  resolution: "@babel/parser@npm:7.28.5"
   dependencies:
-    "@babel/types": "npm:^7.28.4"
+    "@babel/types": "npm:^7.28.5"
   bin:
     parser: ./bin/babel-parser.js
-  checksum: 10c0/58b239a5b1477ac7ed7e29d86d675cc81075ca055424eba6485872626db2dc556ce63c45043e5a679cd925e999471dba8a3ed4864e7ab1dbf64306ab72c52707
+  checksum: 10c0/5bbe48bf2c79594ac02b490a41ffde7ef5aa22a9a88ad6bcc78432a6ba8a9d638d531d868bd1f104633f1f6bba9905746e15185b8276a3756c42b765d131b1ef
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.28.5":
-  version: 7.28.5
-  resolution: "@babel/parser@npm:7.28.5"
+"@babel/parser@npm:^7.28.3, @babel/parser@npm:^7.28.4":
+  version: 7.28.4
+  resolution: "@babel/parser@npm:7.28.4"
   dependencies:
-    "@babel/types": "npm:^7.28.5"
+    "@babel/types": "npm:^7.28.4"
   bin:
     parser: ./bin/babel-parser.js
-  checksum: 10c0/5bbe48bf2c79594ac02b490a41ffde7ef5aa22a9a88ad6bcc78432a6ba8a9d638d531d868bd1f104633f1f6bba9905746e15185b8276a3756c42b765d131b1ef
+  checksum: 10c0/58b239a5b1477ac7ed7e29d86d675cc81075ca055424eba6485872626db2dc556ce63c45043e5a679cd925e999471dba8a3ed4864e7ab1dbf64306ab72c52707
   languageName: node
   linkType: hard
 
@@ -1819,19 +1778,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-destructuring@npm:^7.27.3, @babel/plugin-transform-destructuring@npm:^7.28.0":
-  version: 7.28.0
-  resolution: "@babel/plugin-transform-destructuring@npm:7.28.0"
-  dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.27.1"
-    "@babel/traverse": "npm:^7.28.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10c0/cc7ccafa952b3ff7888544d5688cfafaba78c69ce1e2f04f3233f4f78c9de5e46e9695f5ea42c085b0c0cfa39b10f366d362a2be245b6d35b66d3eb1d427ccb2
-  languageName: node
-  linkType: hard
-
-"@babel/plugin-transform-destructuring@npm:^7.28.5":
+"@babel/plugin-transform-destructuring@npm:^7.27.3, @babel/plugin-transform-destructuring@npm:^7.28.0, @babel/plugin-transform-destructuring@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/plugin-transform-destructuring@npm:7.28.5"
   dependencies:
@@ -2137,19 +2084,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-optional-chaining@npm:^7.24.7, @babel/plugin-transform-optional-chaining@npm:^7.27.1":
-  version: 7.27.1
-  resolution: "@babel/plugin-transform-optional-chaining@npm:7.27.1"
-  dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.27.1"
-    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.27.1"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10c0/5b18ff5124e503f0a25d6b195be7351a028b3992d6f2a91fb4037e2a2c386400d66bc1df8f6df0a94c708524f318729e81a95c41906e5a7919a06a43e573a525
-  languageName: node
-  linkType: hard
-
-"@babel/plugin-transform-optional-chaining@npm:^7.28.5":
+"@babel/plugin-transform-optional-chaining@npm:^7.24.7, @babel/plugin-transform-optional-chaining@npm:^7.27.1, @babel/plugin-transform-optional-chaining@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/plugin-transform-optional-chaining@npm:7.28.5"
   dependencies:
@@ -2546,22 +2481,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/traverse@npm:^7.25.9, @babel/traverse@npm:^7.26.10, @babel/traverse@npm:^7.27.1, @babel/traverse@npm:^7.28.0, @babel/traverse@npm:^7.28.3, @babel/traverse@npm:^7.28.4":
-  version: 7.28.4
-  resolution: "@babel/traverse@npm:7.28.4"
-  dependencies:
-    "@babel/code-frame": "npm:^7.27.1"
-    "@babel/generator": "npm:^7.28.3"
-    "@babel/helper-globals": "npm:^7.28.0"
-    "@babel/parser": "npm:^7.28.4"
-    "@babel/template": "npm:^7.27.2"
-    "@babel/types": "npm:^7.28.4"
-    debug: "npm:^4.3.1"
-  checksum: 10c0/ee678fdd49c9f54a32e07e8455242390d43ce44887cea6567b233fe13907b89240c377e7633478a32c6cf1be0e17c2f7f3b0c59f0666e39c5074cc47b968489c
-  languageName: node
-  linkType: hard
-
-"@babel/traverse@npm:^7.28.5":
+"@babel/traverse@npm:^7.25.9, @babel/traverse@npm:^7.26.10, @babel/traverse@npm:^7.27.1, @babel/traverse@npm:^7.28.0, @babel/traverse@npm:^7.28.3, @babel/traverse@npm:^7.28.4, @babel/traverse@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/traverse@npm:7.28.5"
   dependencies:
@@ -2576,23 +2496,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.26.0, @babel/types@npm:^7.26.10, @babel/types@npm:^7.27.1, @babel/types@npm:^7.27.3, @babel/types@npm:^7.28.2, @babel/types@npm:^7.28.4, @babel/types@npm:^7.4.4":
-  version: 7.28.4
-  resolution: "@babel/types@npm:7.28.4"
+"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.26.0, @babel/types@npm:^7.26.10, @babel/types@npm:^7.27.1, @babel/types@npm:^7.27.3, @babel/types@npm:^7.28.4, @babel/types@npm:^7.28.5, @babel/types@npm:^7.4.4":
+  version: 7.28.5
+  resolution: "@babel/types@npm:7.28.5"
   dependencies:
     "@babel/helper-string-parser": "npm:^7.27.1"
-    "@babel/helper-validator-identifier": "npm:^7.27.1"
-  checksum: 10c0/ac6f909d6191319e08c80efbfac7bd9a25f80cc83b43cd6d82e7233f7a6b9d6e7b90236f3af7400a3f83b576895bcab9188a22b584eb0f224e80e6d4e95f4517
+    "@babel/helper-validator-identifier": "npm:^7.28.5"
+  checksum: 10c0/a5a483d2100befbf125793640dec26b90b95fd233a94c19573325898a5ce1e52cdfa96e495c7dcc31b5eca5b66ce3e6d4a0f5a4a62daec271455959f208ab08a
   languageName: node
   linkType: hard
 
-"@babel/types@npm:^7.28.5":
-  version: 7.28.5
-  resolution: "@babel/types@npm:7.28.5"
+"@babel/types@npm:^7.28.2":
+  version: 7.28.4
+  resolution: "@babel/types@npm:7.28.4"
   dependencies:
     "@babel/helper-string-parser": "npm:^7.27.1"
-    "@babel/helper-validator-identifier": "npm:^7.28.5"
-  checksum: 10c0/a5a483d2100befbf125793640dec26b90b95fd233a94c19573325898a5ce1e52cdfa96e495c7dcc31b5eca5b66ce3e6d4a0f5a4a62daec271455959f208ab08a
+    "@babel/helper-validator-identifier": "npm:^7.27.1"
+  checksum: 10c0/ac6f909d6191319e08c80efbfac7bd9a25f80cc83b43cd6d82e7233f7a6b9d6e7b90236f3af7400a3f83b576895bcab9188a22b584eb0f224e80e6d4e95f4517
   languageName: node
   linkType: hard
 
@@ -4522,6 +4442,7 @@ __metadata:
     "@graphql-mesh/transport-common": "workspace:^"
     "@graphql-mesh/types": "npm:^0.104.14"
     "@graphql-mesh/utils": "npm:^0.104.14"
+    "@graphql-tools/executor": "npm:^1.4.9"
     "@graphql-tools/utils": "npm:^10.10.0"
     "@opentelemetry/api": "npm:^1.9.0"
     "@opentelemetry/api-logs": "npm:^0.207.0"
@@ -5317,27 +5238,11 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@graphql-tools/executor@npm:^1.3.2, @graphql-tools/executor@npm:^1.3.6, @graphql-tools/executor@npm:^1.4.0":
-  version: 1.4.9
-  resolution: "@graphql-tools/executor@npm:1.4.9"
-  dependencies:
-    "@graphql-tools/utils": "npm:^10.9.1"
-    "@graphql-typed-document-node/core": "npm:^3.2.0"
-    "@repeaterjs/repeater": "npm:^3.0.4"
-    "@whatwg-node/disposablestack": "npm:^0.0.6"
-    "@whatwg-node/promise-helpers": "npm:^1.0.0"
-    tslib: "npm:^2.4.0"
-  peerDependencies:
-    graphql: ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0
-  checksum: 10c0/71c8818915e62cdeaf5aec3ffbb6a98d158aacb809258059a0f7695c456a8457f9fd0a007924869f72cca4196cbe0076c5f520c7c7e493b85deba1d3610b1b93
-  languageName: node
-  linkType: hard
-
-"@graphql-tools/executor@npm:^1.4.10":
-  version: 1.4.10
-  resolution: "@graphql-tools/executor@npm:1.4.10"
+"@graphql-tools/executor@npm:1.5.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b":
+  version: 1.5.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b
+  resolution: "@graphql-tools/executor@npm:1.5.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b"
   dependencies:
-    "@graphql-tools/utils": "npm:^10.10.0"
+    "@graphql-tools/utils": "npm:10.10.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b"
     "@graphql-typed-document-node/core": "npm:^3.2.0"
     "@repeaterjs/repeater": "npm:^3.0.4"
     "@whatwg-node/disposablestack": "npm:^0.0.6"
@@ -5345,7 +5250,7 @@ __metadata:
     tslib: "npm:^2.4.0"
   peerDependencies:
     graphql: ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0
-  checksum: 10c0/cf5857897456b60ccfaaca7b596331c1666736ec31735069efa0e6c128ad2bec9bec503016c3dad46a537beab90ff62d9b69330e6184568ae3b8cd94612fc2ec
+  checksum: 10c0/35654349ebaa55d0751b9fcf63cd16ae3f63ac80ba31150e0fb008eb5b29249280bd8c975dbc3e69f688638e83af2fc9f2e95cd8726d8a2b80a7a30d1d530976
   languageName: node
   linkType: hard
 
@@ -5381,17 +5286,17 @@ __metadata:
   linkType: soft
 
 "@graphql-tools/graphql-file-loader@npm:^8.0.5":
-  version: 8.1.1
-  resolution: "@graphql-tools/graphql-file-loader@npm:8.1.1"
+  version: 8.1.2
+  resolution: "@graphql-tools/graphql-file-loader@npm:8.1.2"
   dependencies:
-    "@graphql-tools/import": "npm:7.1.1"
+    "@graphql-tools/import": "npm:7.1.2"
     "@graphql-tools/utils": "npm:^10.9.1"
     globby: "npm:^11.0.3"
     tslib: "npm:^2.4.0"
     unixify: "npm:^1.0.0"
   peerDependencies:
     graphql: ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0
-  checksum: 10c0/d3d5ee1f9867acf1acaf06ae6c309dc52fdf31c225f27ea04d1a37d701831a24608edb0693b047df7efcfa61c0559a0181d793515f7baba4c1b39d34c9567020
+  checksum: 10c0/a9a268dc8206437d1b434df5d0a42d27475e219ac262eada1ba62e932a5d7ce76ae43ed462de61f07811082eee1917a984c9f00eb478b91e9818c0bd6167636b
   languageName: node
   linkType: hard
 
@@ -5444,17 +5349,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@graphql-tools/import@npm:7.1.1":
-  version: 7.1.1
-  resolution: "@graphql-tools/import@npm:7.1.1"
+"@graphql-tools/import@npm:7.1.2":
+  version: 7.1.2
+  resolution: "@graphql-tools/import@npm:7.1.2"
   dependencies:
     "@graphql-tools/utils": "npm:^10.9.1"
-    "@theguild/federation-composition": "npm:^0.19.0"
+    "@theguild/federation-composition": "npm:^0.20.1"
     resolve-from: "npm:5.0.0"
     tslib: "npm:^2.4.0"
   peerDependencies:
     graphql: ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0
-  checksum: 10c0/6d163e9099eca1e8cf0e05a854b9570f19ddcdb870f83b7a0835047dde029a0e37dc57b56d7a911ab5b7a00da54cf45a17b34be51cb03a99149f71ebf10f4396
+  checksum: 10c0/dfdb6984a03a88b88e357a45c065a3d4fd2e1e3a77f2c85ef7346b56f68665fc9d35f6cc0d93ef4ced3cd8e03073c3f4be3b227b941bcdb58b5c8e083ed0c27c
   languageName: node
   linkType: hard
 
@@ -5601,9 +5506,9 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@graphql-tools/utils@npm:10.9.1, @graphql-tools/utils@npm:^10.0.0, @graphql-tools/utils@npm:^10.0.3, @graphql-tools/utils@npm:^10.5.1, @graphql-tools/utils@npm:^10.5.4, @graphql-tools/utils@npm:^10.6.1, @graphql-tools/utils@npm:^10.6.2, @graphql-tools/utils@npm:^10.6.4, @graphql-tools/utils@npm:^10.8.0, @graphql-tools/utils@npm:^10.9.1":
-  version: 10.9.1
-  resolution: "@graphql-tools/utils@npm:10.9.1"
+"@graphql-tools/utils@npm:10.10.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b":
+  version: 10.10.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b
+  resolution: "@graphql-tools/utils@npm:10.10.0-alpha-20251028202445-48fa8e9d55723fbb44d9d07fdcd9585d7c50607b"
   dependencies:
     "@graphql-typed-document-node/core": "npm:^3.1.1"
     "@whatwg-node/promise-helpers": "npm:^1.0.0"
@@ -5612,33 +5517,7 @@ __metadata:
     tslib: "npm:^2.4.0"
   peerDependencies:
     graphql: ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0
-  checksum: 10c0/97199f52d0235124d4371f7f54cc0df5ce9df6d8aae716ac05d8ebeda4b5ee3faf1fca94d5d1c521a565e152f8e02a1abfb9c2629ffe805c14468aec0c3d41cf
-  languageName: node
-  linkType: hard
-
-"@graphql-tools/utils@npm:^10.10.0":
-  version: 10.10.0
-  resolution: "@graphql-tools/utils@npm:10.10.0"
-  dependencies:
-    "@graphql-typed-document-node/core": "npm:^3.1.1"
-    "@whatwg-node/promise-helpers": "npm:^1.0.0"
-    cross-inspect: "npm:1.0.1"
-    dset: "npm:^3.1.4"
-    tslib: "npm:^2.4.0"
-  peerDependencies:
-    graphql: ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0
-  checksum: 10c0/bf34f80c268e16bcc10398d0d5e304f55772e46eef404db7f87a09c0f421935759a39d927a0f27bd18c828c78f75dd0395c6b5d1e904ffd0f52b98b2b4bd7291
-  languageName: node
-  linkType: hard
-
-"@graphql-tools/utils@npm:^8.5.2":
-  version: 8.13.1
-  resolution: "@graphql-tools/utils@npm:8.13.1"
-  dependencies:
-    tslib: "npm:^2.4.0"
-  peerDependencies:
-    graphql: ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0
-  checksum: 10c0/f9bab1370aa91e706abec4c8ea980e15293cb78bd4effba53ad2365dc39d81148db7667b3ef89b35f0a0b0ad58081ffdac4264b7125c69fa8393590ae5025745
+  checksum: 10c0/7b752de3ef6762a8be02540f30ecf4015f146062246082694f77d301deb6e23e46d25ea1b96004c8aef318538b3223c68a761f55c0ad2457283b968afc92d917
   languageName: node
   linkType: hard
 
@@ -6243,7 +6122,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ioredis/commands@npm:^1.2.0, @ioredis/commands@npm:^1.3.0":
+"@ioredis/commands@npm:^1.2.0":
   version: 1.3.0
   resolution: "@ioredis/commands@npm:1.3.0"
   checksum: 10c0/5ab990a8f69c20daf3d7d64307aa9f13ee727c92ab4c7664a6943bb500227667a0c368892e9c4913f06416377db47dba78d58627fe723da476d25f2c04a6d5aa
@@ -7201,7 +7080,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@opentelemetry/core@npm:2.1.0, @opentelemetry/core@npm:^2.0.0":
+"@opentelemetry/core@npm:2.1.0":
   version: 2.1.0
   resolution: "@opentelemetry/core@npm:2.1.0"
   dependencies:
@@ -7212,7 +7091,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@opentelemetry/core@npm:2.2.0, @opentelemetry/core@npm:^2.2.0":
+"@opentelemetry/core@npm:2.2.0, @opentelemetry/core@npm:^2.0.0, @opentelemetry/core@npm:^2.2.0":
   version: 2.2.0
   resolution: "@opentelemetry/core@npm:2.2.0"
   dependencies:
@@ -9516,23 +9395,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@theguild/federation-composition@npm:^0.19.0":
-  version: 0.19.1
-  resolution: "@theguild/federation-composition@npm:0.19.1"
-  dependencies:
-    constant-case: "npm:^3.0.4"
-    debug: "npm:4.4.1"
-    json5: "npm:^2.2.3"
-    lodash.sortby: "npm:^4.7.0"
-  peerDependencies:
-    graphql: ^16.0.0
-  checksum: 10c0/f5a1a9a89beaea4e5b152a05583d26d1a06ecc4139451a954f92894a22d24d99d7696842724d41d85fb3fa5e2976f4d2f07a49a914b4151a45ce70e81471c3a9
-  languageName: node
-  linkType: hard
-
-"@theguild/federation-composition@npm:^0.20.0":
-  version: 0.20.0
-  resolution: "@theguild/federation-composition@npm:0.20.0"
+"@theguild/federation-composition@npm:^0.20.0, @theguild/federation-composition@npm:^0.20.1":
+  version: 0.20.1
+  resolution: "@theguild/federation-composition@npm:0.20.1"
   dependencies:
     constant-case: "npm:^3.0.4"
     debug: "npm:4.4.1"
@@ -9540,7 +9405,7 @@ __metadata:
     lodash.sortby: "npm:^4.7.0"
   peerDependencies:
     graphql: ^16.0.0
-  checksum: 10c0/a5b51aa7a8935e0b035d01ebba9e321060cb3687435ce34b89e637207aa3d2a303b674cac5aa54cedb2eaeac0a4ec99b0923e8af0533b77202df1c8ca4c82b26
+  checksum: 10c0/1f1172bb0f32fb95bca96e0432adc82f158655bcbef5b2f258a7a5679673525c8e5f7695deb2b9e2991a1ff302c17e6049abb29d0ac835aa0a7b89a813085614
   languageName: node
   linkType: hard
 
@@ -11702,14 +11567,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-styles@npm:^6.1.0":
-  version: 6.2.1
-  resolution: "ansi-styles@npm:6.2.1"
-  checksum: 10c0/5d1ec38c123984bcedd996eac680d548f31828bd679a66db2bdf11844634dde55fec3efa9c6bb1d89056a5e79c1ac540c4c784d592ea1d25028a92227d2f2d5c
-  languageName: node
-  linkType: hard
-
-"ansi-styles@npm:^6.2.1":
+"ansi-styles@npm:^6.1.0, ansi-styles@npm:^6.2.1":
   version: 6.2.3
   resolution: "ansi-styles@npm:6.2.3"
   checksum: 10c0/23b8a4ce14e18fb854693b95351e286b771d23d8844057ed2e7d083cd3e708376c3323707ec6a24365f7d7eda3ca00327fe04092e29e551499ec4c8b7bfac868
@@ -14706,13 +14564,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-redact@npm:^3.1.1":
-  version: 3.5.0
-  resolution: "fast-redact@npm:3.5.0"
-  checksum: 10c0/7e2ce4aad6e7535e0775bf12bd3e4f2e53d8051d8b630e0fa9e67f68cb0b0e6070d2f7a94b1d0522ef07e32f7c7cda5755e2b677a6538f1e9070ca053c42343a
-  languageName: node
-  linkType: hard
-
 "fast-safe-stringify@npm:2.1.1, fast-safe-stringify@npm:^2.1.1":
   version: 2.1.1
   resolution: "fast-safe-stringify@npm:2.1.1"
@@ -16196,24 +16047,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ioredis@npm:^5.3.2":
-  version: 5.7.0
-  resolution: "ioredis@npm:5.7.0"
-  dependencies:
-    "@ioredis/commands": "npm:^1.3.0"
-    cluster-key-slot: "npm:^1.1.0"
-    debug: "npm:^4.3.4"
-    denque: "npm:^2.1.0"
-    lodash.defaults: "npm:^4.2.0"
-    lodash.isarguments: "npm:^3.1.0"
-    redis-errors: "npm:^1.2.0"
-    redis-parser: "npm:^3.0.0"
-    standard-as-callback: "npm:^2.1.0"
-  checksum: 10c0/c63c521a953bfaf29f8c8871b122af38e439328336fa238f83bfbb066556f64daf69ed7a4ec01fc7b9ee1f0862059dd188b8c684150125d362d36642399b30ee
-  languageName: node
-  linkType: hard
-
-"ioredis@npm:^5.8.2":
+"ioredis@npm:^5.3.2, ioredis@npm:^5.8.2":
   version: 5.8.2
   resolution: "ioredis@npm:5.8.2"
   dependencies:
@@ -19399,28 +19233,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pino@npm:^9.0.0":
-  version: 9.10.0
-  resolution: "pino@npm:9.10.0"
-  dependencies:
-    atomic-sleep: "npm:^1.0.0"
-    fast-redact: "npm:^3.1.1"
-    on-exit-leak-free: "npm:^2.1.0"
-    pino-abstract-transport: "npm:^2.0.0"
-    pino-std-serializers: "npm:^7.0.0"
-    process-warning: "npm:^5.0.0"
-    quick-format-unescaped: "npm:^4.0.3"
-    real-require: "npm:^0.2.0"
-    safe-stable-stringify: "npm:^2.3.1"
-    sonic-boom: "npm:^4.0.1"
-    thread-stream: "npm:^3.0.0"
-  bin:
-    pino: bin.js
-  checksum: 10c0/42fb5a800e51e8cacf3ec0f0b03183775219e4248bd10f0638741f21eabfb58f904ec2ed4ec79d40850bc42725c7414ec3c3e69f7c0a21450ce12d181deeb278
-  languageName: node
-  linkType: hard
-
-"pino@npm:^9.13.0":
+"pino@npm:^9.0.0, pino@npm:^9.13.0":
   version: 9.13.0
   resolution: "pino@npm:9.13.0"
   dependencies:
@@ -20625,16 +20438,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"semver@npm:^7.1.2, semver@npm:^7.3.5, semver@npm:^7.5.2, semver@npm:^7.5.3, semver@npm:^7.5.4, semver@npm:^7.6.0, semver@npm:^7.6.3, semver@npm:^7.7.2":
-  version: 7.7.2
-  resolution: "semver@npm:7.7.2"
-  bin:
-    semver: bin/semver.js
-  checksum: 10c0/aca305edfbf2383c22571cb7714f48cadc7ac95371b4b52362fb8eeffdfbc0de0669368b82b2b15978f8848f01d7114da65697e56cd8c37b0dab8c58e543f9ea
-  languageName: node
-  linkType: hard
-
-"semver@npm:^7.7.3":
+"semver@npm:^7.1.2, semver@npm:^7.3.5, semver@npm:^7.5.2, semver@npm:^7.5.3, semver@npm:^7.5.4, semver@npm:^7.6.0, semver@npm:^7.6.3, semver@npm:^7.7.2, semver@npm:^7.7.3":
   version: 7.7.3
   resolution: "semver@npm:7.7.3"
   bin:
@@ -21418,16 +21222,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-ansi@npm:^7.0.1":
-  version: 7.1.0
-  resolution: "strip-ansi@npm:7.1.0"
-  dependencies:
-    ansi-regex: "npm:^6.0.1"
-  checksum: 10c0/a198c3762e8832505328cbf9e8c8381de14a4fa50a4f9b2160138158ea88c0f5549fb50cb13c651c3088f47e63a108b34622ec18c0499b6c8c3a5ddf6b305ac4
-  languageName: node
-  linkType: hard
-
-"strip-ansi@npm:^7.1.0":
+"strip-ansi@npm:^7.0.1, strip-ansi@npm:^7.1.0":
   version: 7.1.2
   resolution: "strip-ansi@npm:7.1.2"
   dependencies: