ref(serverless): Convert integrations to functional approach (#10329)

This PR updates the serverless integrations to use the functional
approach, and rewrites all of the serverless unit tests.

In the unit test rewrite we remove the usage of global mocks and instead
do per file mocks. I dislike the amount of mocks that still exist, but
to prevent any regressions I only tried to translate the test code.

Author: AbhiPrasad

packages/serverless/src/awslambda.ts

@@ -2,7 +2,6 @@ import { existsSync } from 'fs';
 import { hostname } from 'os';
 import { basename, resolve } from 'path';
 import { types } from 'util';
-/* eslint-disable max-lines */
 import type { NodeOptions, Scope } from '@sentry/node';
 import { SDK_VERSION } from '@sentry/node';
 import {
@@ -19,12 +18,12 @@ import {
 } from '@sentry/node';
 import type { Integration, Options, SdkMetadata, Span } from '@sentry/types';
 import { isString, logger } from '@sentry/utils';
-// NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 import type { Context, Handler } from 'aws-lambda';
 import { performance } from 'perf_hooks';
 
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
-import { AWSServices } from './awsservices';
+import { awsServicesIntegration } from './awsservices';
+
 import { DEBUG_BUILD } from './debug-build';
 import { markEventUnhandled } from './utils';
 
@@ -71,12 +70,12 @@ export interface WrapperOptions {
 export const defaultIntegrations: Integration[] = [
   // eslint-disable-next-line deprecation/deprecation
   ...nodeDefaultIntegrations,
-  new AWSServices({ optional: true }),
+  awsServicesIntegration({ optional: true }),
 ];
 
 /** Get the default integrations for the AWSLambda SDK. */
 export function getDefaultIntegrations(options: Options): Integration[] {
-  return [...getNodeDefaultIntegrations(options), new AWSServices({ optional: true })];
+  return [...getNodeDefaultIntegrations(options), awsServicesIntegration({ optional: true })];
 }
 
 interface AWSLambdaOptions extends NodeOptions {

packages/serverless/src/awsservices.ts

@@ -1,6 +1,6 @@
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
-import { startInactiveSpan } from '@sentry/node';
-import type { Integration, Span } from '@sentry/types';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, convertIntegrationFnToClass, defineIntegration } from '@sentry/core';
+import { getClient, startInactiveSpan } from '@sentry/node';
+import type { Client, Integration, IntegrationClass, IntegrationFn, Span } from '@sentry/types';
 import { fill } from '@sentry/utils';
 // 'aws-sdk/global' 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.
@@ -16,63 +16,73 @@ interface AWSService {
   serviceIdentifier: string;
 }
 
-/** AWS service requests tracking */
-export class AWSServices implements Integration {
-  /**
-   * @inheritDoc
-   */
-  public static id: string = 'AWSServices';
+const INTEGRATION_NAME = 'AWSServices';
 
-  /**
-   * @inheritDoc
-   */
-  public name: string;
+const SETUP_CLIENTS = new WeakMap<Client, boolean>();
 
-  private readonly _optional: boolean;
+const _awsServicesIntegration = ((options: { optional?: boolean } = {}) => {
+  const optional = options.optional || false;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const awsModule = require('aws-sdk/global') as typeof AWS;
+        fill(awsModule.Service.prototype, 'makeRequest', wrapMakeRequest);
+      } catch (e) {
+        if (!optional) {
+          throw e;
+        }
+      }
+    },
+    setup(client) {
+      SETUP_CLIENTS.set(client, true);
+    },
+  };
+}) satisfies IntegrationFn;
 
-  public constructor(options: { optional?: boolean } = {}) {
-    this.name = AWSServices.id;
+export const awsServicesIntegration = defineIntegration(_awsServicesIntegration);
 
-    this._optional = options.optional || false;
-  }
+/**
+ * AWS Service Request Tracking.
+ *
+ * @deprecated Use `awsServicesIntegration()` instead.
+ */
+// eslint-disable-next-line deprecation/deprecation
+export const AWSServices = convertIntegrationFnToClass(
+  INTEGRATION_NAME,
+  awsServicesIntegration,
+) as IntegrationClass<Integration>;
 
-  /**
-   * @inheritDoc
-   */
-  public setupOnce(): void {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const awsModule = require('aws-sdk/global') as typeof AWS;
-      fill(awsModule.Service.prototype, 'makeRequest', wrapMakeRequest);
-    } catch (e) {
-      if (!this._optional) {
-        throw e;
-      }
-    }
-  }
-}
+// eslint-disable-next-line deprecation/deprecation
+export type AWSServices = typeof AWSServices;
 
-/** */
+/**
+ * Patches AWS SDK request to create `http.client` spans.
+ */
 function wrapMakeRequest<TService extends AWSService, TResult>(
   orig: MakeRequestFunction<GenericParams, TResult>,
 ): MakeRequestFunction<GenericParams, TResult> {
   return function (this: TService, operation: string, params?: GenericParams, callback?: MakeRequestCallback<TResult>) {
     let span: Span | undefined;
     const req = orig.call(this, operation, params);
-    req.on('afterBuild', () => {
-      span = startInactiveSpan({
-        name: describe(this, operation, params),
-        op: 'http.client',
-        attributes: {
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.serverless',
-        },
+
+    if (SETUP_CLIENTS.has(getClient() as Client)) {
+      req.on('afterBuild', () => {
+        span = startInactiveSpan({
+          name: describe(this, operation, params),
+          op: 'http.client',
+          attributes: {
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.serverless',
+          },
+        });
       });
-    });
-    req.on('complete', () => {
-      if (span) {
-        span.end();
-      }
-    });
+      req.on('complete', () => {
+        if (span) {
+          span.end();
+        }
+      });
+    }
 
     if (callback) {
       req.send(callback);

packages/serverless/src/gcpfunction/index.ts

@@ -7,8 +7,8 @@ import {
 } from '@sentry/node';
 import type { Integration, Options, SdkMetadata } from '@sentry/types';
 
-import { GoogleCloudGrpc } from '../google-cloud-grpc';
-import { GoogleCloudHttp } from '../google-cloud-http';
+import { googleCloudGrpcIntegration } from '../google-cloud-grpc';
+import { googleCloudHttpIntegration } from '../google-cloud-http';
 
 export * from './http';
 export * from './events';
@@ -18,16 +18,16 @@ 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.
-  new GoogleCloudGrpc({ optional: true }), // We mark this integration optional since 'google-gax' 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.
-    new GoogleCloudGrpc({ optional: true }), // We mark this integration optional since 'google-gax' 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-grpc.ts

@@ -1,7 +1,12 @@
 import type { EventEmitter } from 'events';
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import {
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  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';
 
 interface GrpcFunction extends CallableFunction {
@@ -26,45 +31,52 @@ interface Stub {
   [key: string]: GrpcFunctionObject;
 }
 
-/** Google Cloud Platform service requests tracking for GRPC APIs */
-export class GoogleCloudGrpc implements Integration {
-  /**
-   * @inheritDoc
-   */
-  public static id: string = 'GoogleCloudGrpc';
+const SERVICE_PATH_REGEX = /^(\w+)\.googleapis.com$/;
 
-  /**
-   * @inheritDoc
-   */
-  public name: string;
+const INTEGRATION_NAME = 'GoogleCloudGrpc';
 
-  private readonly _optional: boolean;
+const SETUP_CLIENTS = new WeakMap<Client, boolean>();
 
-  public constructor(options: { optional?: boolean } = {}) {
-    this.name = GoogleCloudGrpc.id;
+const _googleCloudGrpcIntegration = ((options: { optional?: boolean } = {}) => {
+  const optional = options.optional || false;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const gaxModule = require('google-gax');
+        fill(
+          gaxModule.GrpcClient.prototype, // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+          'createStub',
+          wrapCreateStub,
+        );
+      } catch (e) {
+        if (!optional) {
+          throw e;
+        }
+      }
+    },
+    setup(client) {
+      SETUP_CLIENTS.set(client, true);
+    },
+  };
+}) satisfies IntegrationFn;
 
-    this._optional = options.optional || false;
-  }
+export const googleCloudGrpcIntegration = defineIntegration(_googleCloudGrpcIntegration);
 
-  /**
-   * @inheritDoc
-   */
-  public setupOnce(): void {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const gaxModule = require('google-gax');
-      fill(
-        gaxModule.GrpcClient.prototype, // eslint-disable-line @typescript-eslint/no-unsafe-member-access
-        'createStub',
-        wrapCreateStub,
-      );
-    } catch (e) {
-      if (!this._optional) {
-        throw e;
-      }
-    }
-  }
-}
+/**
+ * Google Cloud Platform service requests tracking for GRPC APIs.
+ *
+ * @deprecated Use `googleCloudGrpcIntegration()` instead.
+ */
+// eslint-disable-next-line deprecation/deprecation
+export const GoogleCloudGrpc = convertIntegrationFnToClass(
+  INTEGRATION_NAME,
+  googleCloudGrpcIntegration,
+) as IntegrationClass<Integration>;
+
+// eslint-disable-next-line deprecation/deprecation
+export type GoogleCloudGrpc = typeof GoogleCloudGrpc;
 
 /** Returns a wrapped function that returns a stub with tracing enabled */
 function wrapCreateStub(origCreate: CreateStubFunc): CreateStubFunc {
@@ -105,7 +117,7 @@ function fillGrpcFunction(stub: Stub, serviceIdentifier: string, methodName: str
     (orig: GrpcFunction): GrpcFunction =>
       (...args) => {
         const ret = orig.apply(stub, args);
-        if (typeof ret?.on !== 'function') {
+        if (typeof ret?.on !== 'function' || !SETUP_CLIENTS.has(getClient() as Client)) {
           return ret;
         }
         const span = startInactiveSpan({
@@ -127,6 +139,6 @@ function fillGrpcFunction(stub: Stub, serviceIdentifier: string, methodName: str
 
 /** Identifies service by its address */
 function identifyService(servicePath: string): string {
-  const match = servicePath.match(/^(\w+)\.googleapis.com$/);
+  const match = servicePath.match(SERVICE_PATH_REGEX);
   return match ? match[1] : servicePath;
 }