Merge branch 'develop' into fix/cloudflare-double-instrumentation-flake

Author: JPeer264

.oxlintrc.base.json

@@ -156,7 +156,8 @@
         "**/integrations/tracing/tedious/vendored/**/*.ts",
         "**/integrations/tracing/hapi/vendored/**/*.ts",
         "**/integrations/tracing/mongoose/vendored/**/*.ts",
-        "**/integrations/tracing/amqplib/vendored/**/*.ts"
+        "**/integrations/tracing/amqplib/vendored/**/*.ts",
+        "**/integrations/tracing/graphql/vendored/**/*.ts"
       ],
       "rules": {
         "typescript/no-explicit-any": "off"

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
-Work in this release was contributed by @abcang, @ahmadio, and @victorgarciaesgi. Thank you for your contributions!
+Work in this release was contributed by @abcang, @ahmadio, @victorgarciaesgi, and @delorge. Thank you for your contributions!
 
 - **feat(core): Support array attributes for spans, logs, and metrics ([#20427](https://github.com/getsentry/sentry-javascript/pull/20427))**
 

packages/cloudflare/src/instrumentations/worker/instrumentFetch.ts

@@ -25,6 +25,11 @@ export function instrumentExportedHandlerFetch<T extends ExportedHandler<any, an
       new Proxy(original, {
         apply(target, thisArg, args: Parameters<NonNullable<T['fetch']>>) {
           const [request, env, ctx] = args;
+
+          if (request.method === 'OPTIONS' || request.method === 'HEAD') {
+            return target.apply(thisArg, args);
+          }
+
           const context = instrumentContext(ctx);
           const options = getFinalOptions(optionsCallback(env), env);
           args[1] = instrumentEnv(env, options);
@@ -53,6 +58,10 @@ export function instrumentWorkerEntrypointFetch<T extends WorkerEntrypoint>(
     apply(target, thisArg, args: [Request]) {
       const [request] = args;
 
+      if (request.method === 'OPTIONS' || request.method === 'HEAD') {
+        return Reflect.apply(target, thisArg, args);
+      }
+
       return wrapRequestHandler({ options, request, context }, () => Reflect.apply(target, thisArg, args));
     },
   });

packages/cloudflare/src/pages-plugin.ts

@@ -48,6 +48,10 @@ export function sentryPagesPlugin<
 ): PagesPluginFunction<Env, Params, Data, PluginParams> {
   setAsyncLocalStorageAsyncContextStrategy();
   return context => {
+    if (context.request.method === 'OPTIONS' || context.request.method === 'HEAD') {
+      return context.next();
+    }
+
     const options = typeof handlerOrOptions === 'function' ? handlerOrOptions(context) : handlerOrOptions;
     return wrapRequestHandler({ options, request: context.request, context: { ...context, props: {} } }, () =>
       context.next(),

packages/cloudflare/test/instrumentations/worker/instrumentFetch.test.ts

@@ -174,4 +174,85 @@ describe('instrumentFetch', () => {
     await Promise.all(waits);
     expect(flush).toHaveBeenCalledOnce();
   });
+
+  test('OPTIONS requests bypass SDK instrumentation', async () => {
+    const originalFetch = vi.fn().mockReturnValue(new Response('options response'));
+    const handler = {
+      fetch: originalFetch,
+    } satisfies ExportedHandler<typeof MOCK_ENV>;
+
+    const optionsCallback = vi.fn().mockReturnValue({ dsn: MOCK_ENV.SENTRY_DSN });
+
+    const wrappedHandler = withSentry(optionsCallback, handler);
+    const result = await wrappedHandler.fetch?.(
+      new Request('https://example.com', { method: 'OPTIONS' }),
+      MOCK_ENV,
+      createMockExecutionContext(),
+    );
+
+    expect(originalFetch).toHaveBeenCalledTimes(1);
+    expect(optionsCallback).not.toHaveBeenCalled();
+    expect(result?.status).toBe(200);
+    if (result) {
+      expect(await result.text()).toBe('options response');
+    }
+  });
+
+  test('HEAD requests bypass SDK instrumentation', async () => {
+    const originalFetch = vi.fn().mockReturnValue(new Response('head response'));
+    const handler = {
+      fetch: originalFetch,
+    } satisfies ExportedHandler<typeof MOCK_ENV>;
+
+    const optionsCallback = vi.fn().mockReturnValue({ dsn: MOCK_ENV.SENTRY_DSN });
+
+    const wrappedHandler = withSentry(optionsCallback, handler);
+    const result = await wrappedHandler.fetch?.(
+      new Request('https://example.com', { method: 'HEAD' }),
+      MOCK_ENV,
+      createMockExecutionContext(),
+    );
+
+    expect(originalFetch).toHaveBeenCalledTimes(1);
+    expect(optionsCallback).not.toHaveBeenCalled();
+    expect(result?.status).toBe(200);
+  });
+
+  test('GET requests are instrumented', async () => {
+    const originalFetch = vi.fn().mockReturnValue(new Response('get response'));
+    const handler = {
+      fetch: originalFetch,
+    } satisfies ExportedHandler<typeof MOCK_ENV>;
+
+    const optionsCallback = vi.fn().mockReturnValue({ dsn: MOCK_ENV.SENTRY_DSN });
+
+    const wrappedHandler = withSentry(optionsCallback, handler);
+    await wrappedHandler.fetch?.(
+      new Request('https://example.com', { method: 'GET' }),
+      MOCK_ENV,
+      createMockExecutionContext(),
+    );
+
+    expect(originalFetch).toHaveBeenCalledTimes(1);
+    expect(optionsCallback).toHaveBeenCalledTimes(1);
+  });
+
+  test('POST requests are instrumented', async () => {
+    const originalFetch = vi.fn().mockReturnValue(new Response('post response'));
+    const handler = {
+      fetch: originalFetch,
+    } satisfies ExportedHandler<typeof MOCK_ENV>;
+
+    const optionsCallback = vi.fn().mockReturnValue({ dsn: MOCK_ENV.SENTRY_DSN });
+
+    const wrappedHandler = withSentry(optionsCallback, handler);
+    await wrappedHandler.fetch?.(
+      new Request('https://example.com', { method: 'POST' }),
+      MOCK_ENV,
+      createMockExecutionContext(),
+    );
+
+    expect(originalFetch).toHaveBeenCalledTimes(1);
+    expect(optionsCallback).toHaveBeenCalledTimes(1);
+  });
 });

packages/cloudflare/test/pages-plugin.test.ts

@@ -56,4 +56,68 @@ describe('sentryPagesPlugin', () => {
     expect(result.status).toBe(response.status);
     expect(await result.text()).toBe('test');
   });
+
+  test('OPTIONS requests bypass SDK instrumentation', async () => {
+    const mockOptionsHandler = vi.fn().mockReturnValue(MOCK_OPTIONS);
+    const mockOnRequest = sentryPagesPlugin(mockOptionsHandler);
+    const mockNext = vi.fn().mockResolvedValue(new Response('options response'));
+
+    const result = await mockOnRequest({
+      request: new Request('https://example.com', { method: 'OPTIONS' }),
+      functionPath: 'test',
+      waitUntil: vi.fn(),
+      passThroughOnException: vi.fn(),
+      next: mockNext,
+      env: { ASSETS: { fetch: vi.fn() } },
+      params: {},
+      data: {},
+      pluginArgs: MOCK_OPTIONS,
+    });
+
+    expect(mockOptionsHandler).not.toHaveBeenCalled();
+    expect(mockNext).toHaveBeenCalledTimes(1);
+    expect(result.status).toBe(200);
+  });
+
+  test('HEAD requests bypass SDK instrumentation', async () => {
+    const mockOptionsHandler = vi.fn().mockReturnValue(MOCK_OPTIONS);
+    const mockOnRequest = sentryPagesPlugin(mockOptionsHandler);
+    const mockNext = vi.fn().mockResolvedValue(new Response('head response'));
+
+    const result = await mockOnRequest({
+      request: new Request('https://example.com', { method: 'HEAD' }),
+      functionPath: 'test',
+      waitUntil: vi.fn(),
+      passThroughOnException: vi.fn(),
+      next: mockNext,
+      env: { ASSETS: { fetch: vi.fn() } },
+      params: {},
+      data: {},
+      pluginArgs: MOCK_OPTIONS,
+    });
+
+    expect(mockOptionsHandler).not.toHaveBeenCalled();
+    expect(mockNext).toHaveBeenCalledTimes(1);
+    expect(result.status).toBe(200);
+  });
+
+  test('GET requests are instrumented', async () => {
+    const mockOptionsHandler = vi.fn().mockReturnValue(MOCK_OPTIONS);
+    const mockOnRequest = sentryPagesPlugin(mockOptionsHandler);
+    const mockNext = vi.fn().mockResolvedValue(new Response('get response'));
+
+    await mockOnRequest({
+      request: new Request('https://example.com', { method: 'GET' }),
+      functionPath: 'test',
+      waitUntil: vi.fn(),
+      passThroughOnException: vi.fn(),
+      next: mockNext,
+      env: { ASSETS: { fetch: vi.fn() } },
+      params: {},
+      data: {},
+      pluginArgs: MOCK_OPTIONS,
+    });
+
+    expect(mockOptionsHandler).toHaveBeenCalledTimes(1);
+  });
 });

packages/node/package.json

@@ -68,7 +68,6 @@
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/core": "^2.6.1",
     "@opentelemetry/instrumentation": "^0.214.0",
-    "@opentelemetry/instrumentation-graphql": "0.62.0",
     "@opentelemetry/instrumentation-http": "0.214.0",
     "@opentelemetry/sql-common": "^0.41.2",
     "@opentelemetry/instrumentation-pg": "0.66.0",

packages/node/src/integrations/tracing/dataloader/vendored/dataloader-types.ts

@@ -2,7 +2,7 @@
  * Simplified types inlined from dataloader.
  */
 
-declare class DataLoader<K, V, C = K> {
+declare class DataLoader<K, V, _C = K> {
   constructor(batchLoadFn: DataLoader.BatchLoadFn<K, V>, options?: any);
   load(key: K): Promise<V>;
   loadMany(keys: ArrayLike<K>): Promise<Array<V | Error>>;

…node/src/integrations/tracing/graphql.ts …rc/integrations/tracing/graphql/index.tspackages/node/src/integrations/tracing/graphql.ts renamed to packages/node/src/integrations/tracing/graphql/index.ts packages/node/src/integrations/tracing/graphql.ts renamed to packages/node/src/integrations/tracing/graphql/index.ts

@@ -1,6 +1,6 @@
 import type { AttributeValue } from '@opentelemetry/api';
 import { SpanStatusCode } from '@opentelemetry/api';
-import { GraphQLInstrumentation } from '@opentelemetry/instrumentation-graphql';
+import { GraphQLInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration, getRootSpan, spanToJSON } from '@sentry/core';
 import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';

packages/node/src/integrations/tracing/graphql/vendored/enum.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * NOTICE from the Sentry authors:
+ * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-graphql
+ * - Upstream version: @opentelemetry/instrumentation-graphql@0.66.0
+ */
+/* eslint-disable */
+
+export enum AllowedOperationTypes {
+  QUERY = 'query',
+  MUTATION = 'mutation',
+  SUBSCRIPTION = 'subscription',
+}
+
+export enum TokenKind {
+  SOF = '<SOF>',
+  EOF = '<EOF>',
+  BANG = '!',
+  DOLLAR = '$',
+  AMP = '&',
+  PAREN_L = '(',
+  PAREN_R = ')',
+  SPREAD = '...',
+  COLON = ':',
+  EQUALS = '=',
+  AT = '@',
+  BRACKET_L = '[',
+  BRACKET_R = ']',
+  BRACE_L = '{',
+  PIPE = '|',
+  BRACE_R = '}',
+  NAME = 'Name',
+  INT = 'Int',
+  FLOAT = 'Float',
+  STRING = 'String',
+  BLOCK_STRING = 'BlockString',
+  COMMENT = 'Comment',
+}
+
+export enum SpanNames {
+  EXECUTE = 'graphql.execute',
+  PARSE = 'graphql.parse',
+  RESOLVE = 'graphql.resolve',
+  VALIDATE = 'graphql.validate',
+  SCHEMA_VALIDATE = 'graphql.validateSchema',
+  SCHEMA_PARSE = 'graphql.parseSchema',
+}