ref(serverless): Convert GoogleCloudHttp to function

Author: AbhiPrasad

packages/serverless/src/gcpfunction/index.ts

@@ -8,7 +8,7 @@ import {
 import type { Integration, Options, SdkMetadata } from '@sentry/types';
 
 import { googleCloudGrpcIntegration } from '../google-cloud-grpc';
-import { GoogleCloudHttp } from '../google-cloud-http';
+import { googleCloudHttpIntegration } from '../google-cloud-http';
 
 export * from './http';
 export * from './events';
@@ -18,15 +18,15 @@ export * from './cloud_events';
 export const defaultIntegrations: Integration[] = [
   // eslint-disable-next-line deprecation/deprecation
   ...defaultNodeIntegrations,
-  new GoogleCloudHttp({ optional: true }), // We mark this integration optional since '@google-cloud/common' module could be missing.
+  googleCloudHttpIntegration({ optional: true }), // We mark this integration optional since '@google-cloud/common' module could be missing.
   googleCloudGrpcIntegration({ optional: true }), // We mark this integration optional since 'google-gax' module could be missing.
 ];
 
 /** Get the default integrations for the GCP SDK. */
 export function getDefaultIntegrations(options: Options): Integration[] {
   return [
     ...getDefaultNodeIntegrations(options),
-    new GoogleCloudHttp({ optional: true }), // We mark this integration optional since '@google-cloud/common' module could be missing.
+    googleCloudHttpIntegration({ optional: true }), // We mark this integration optional since '@google-cloud/common' module could be missing.
     googleCloudGrpcIntegration({ optional: true }), // We mark this integration optional since 'google-gax' module could be missing.
   ];
 }

packages/serverless/src/google-cloud-http.ts

@@ -1,8 +1,7 @@
-// '@google-cloud/common' import is expected to be type-only so it's erased in the final .js file.
-// When TypeScript compiler is upgraded, use `import type` syntax to explicitly assert that we don't want to load a module here.
 import type * as common from '@google-cloud/common';
+import { convertIntegrationFnToClass, defineIntegration, getClient } from '@sentry/core';
 import { startInactiveSpan } from '@sentry/node';
-import type { Integration } from '@sentry/types';
+import type { Client, Integration, IntegrationClass, IntegrationFn } from '@sentry/types';
 import { fill } from '@sentry/utils';
 
 type RequestOptions = common.DecorateRequestOptions;
@@ -12,51 +11,56 @@ interface RequestFunction extends CallableFunction {
   (reqOpts: RequestOptions, callback: ResponseCallback): void;
 }
 
-/** Google Cloud Platform service requests tracking for RESTful APIs */
-export class GoogleCloudHttp implements Integration {
-  /**
-   * @inheritDoc
-   */
-  public static id: string = 'GoogleCloudHttp';
+const INTEGRATION_NAME = 'GoogleCloudHttp';
 
-  /**
-   * @inheritDoc
-   */
-  public name: string;
+const SETUP_CLIENTS = new WeakMap<Client, boolean>();
 
-  private readonly _optional: boolean;
-
-  public constructor(options: { optional?: boolean } = {}) {
-    this.name = GoogleCloudHttp.id;
+const _googleCloudHttpIntegration = ((options: { optional?: boolean } = {}) => {
+  const optional = options.optional || false;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const commonModule = require('@google-cloud/common') as typeof common;
+        fill(commonModule.Service.prototype, 'request', wrapRequestFunction);
+      } catch (e) {
+        if (!optional) {
+          throw e;
+        }
+      }
+    },
+    setup(client) {
+      SETUP_CLIENTS.set(client, true);
+    },
+  };
+}) satisfies IntegrationFn;
 
-    this._optional = options.optional || false;
-  }
+export const googleCloudHttpIntegration = defineIntegration(_googleCloudHttpIntegration);
 
-  /**
-   * @inheritDoc
-   */
-  public setupOnce(): void {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const commonModule = require('@google-cloud/common') as typeof common;
-      fill(commonModule.Service.prototype, 'request', wrapRequestFunction);
-    } catch (e) {
-      if (!this._optional) {
-        throw e;
-      }
-    }
-  }
-}
+/**
+ * Google Cloud Platform service requests tracking for RESTful APIs.
+ *
+ * @deprecated Use `googleCloudHttpIntegration()` instead.
+ */
+// eslint-disable-next-line deprecation/deprecation
+export const GoogleCloudHttp = convertIntegrationFnToClass(
+  INTEGRATION_NAME,
+  googleCloudHttpIntegration,
+) as IntegrationClass<Integration>;
 
 /** Returns a wrapped function that makes a request with tracing enabled */
 function wrapRequestFunction(orig: RequestFunction): RequestFunction {
   return function (this: common.Service, reqOpts: RequestOptions, callback: ResponseCallback): void {
     const httpMethod = reqOpts.method || 'GET';
-    const span = startInactiveSpan({
-      name: `${httpMethod} ${reqOpts.uri}`,
-      op: `http.client.${identifyService(this.apiEndpoint)}`,
-      origin: 'auto.http.serverless',
-    });
+    // Only create span if integration is active on client
+    const span = SETUP_CLIENTS.has(getClient() as Client)
+      ? startInactiveSpan({
+          name: `${httpMethod} ${reqOpts.uri}`,
+          op: `http.client.${identifyService(this.apiEndpoint)}`,
+          origin: 'auto.http.serverless',
+        })
+      : undefined;
     orig.call(this, reqOpts, (...args: Parameters<ResponseCallback>) => {
       if (span) {
         span.end();

packages/serverless/test/google-cloud-http.test.ts

@@ -1,24 +1,45 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { BigQuery } from '@google-cloud/bigquery';
-import * as SentryNode from '@sentry/node';
 import * as nock from 'nock';
 
-import { GoogleCloudHttp } from '../src/google-cloud-http';
+import { NodeClient, createTransport, setCurrentClient } from '@sentry/node';
+import { googleCloudHttpIntegration } from '../src/google-cloud-http';
+
+const mockSpanEnd = jest.fn();
+const mockStartInactiveSpan = jest.fn(spanArgs => ({ ...spanArgs }));
+
+jest.mock('@sentry/node', () => {
+  return {
+    ...jest.requireActual('@sentry/node'),
+    startInactiveSpan: (ctx: unknown) => {
+      mockStartInactiveSpan(ctx);
+      return { end: mockSpanEnd };
+    },
+  };
+});
 
 describe('GoogleCloudHttp tracing', () => {
-  beforeAll(() => {
-    new GoogleCloudHttp().setupOnce();
+  const mockClient = new NodeClient({
+    tracesSampleRate: 1.0,
+    integrations: [],
+    dsn: 'https://withAWSServices@domain/123',
+    transport: () => createTransport({ recordDroppedEvent: () => undefined }, _ => Promise.resolve({})),
+    stackParser: () => [],
   });
+
+  const integration = googleCloudHttpIntegration();
+  mockClient.addIntegration(integration);
+
   beforeEach(() => {
     nock('https://www.googleapis.com')
       .post('/oauth2/v4/token')
       .reply(200, '{"access_token":"a.b.c","expires_in":3599,"token_type":"Bearer"}');
+    setCurrentClient(mockClient);
+    mockSpanEnd.mockClear();
+    mockStartInactiveSpan.mockClear();
   });
-  afterEach(() => {
-    // @ts-expect-error see "Why @ts-expect-error" note
-    SentryNode.resetMocks();
-  });
+
   afterAll(() => {
     nock.restore();
   });
@@ -50,12 +71,12 @@ describe('GoogleCloudHttp tracing', () => {
         );
       const resp = await bigquery.query('SELECT true AS foo');
       expect(resp).toEqual([[{ foo: true }]]);
-      expect(SentryNode.startInactiveSpan).toBeCalledWith({
+      expect(mockStartInactiveSpan).toBeCalledWith({
         op: 'http.client.bigquery',
         origin: 'auto.http.serverless',
         name: 'POST /jobs',
       });
-      expect(SentryNode.startInactiveSpan).toBeCalledWith({
+      expect(mockStartInactiveSpan).toBeCalledWith({
         op: 'http.client.bigquery',
         origin: 'auto.http.serverless',
         name: expect.stringMatching(/^GET \/queries\/.+/),