ref(core): Do not send telemetry data for self-hosted users (#120)

This PR turns telemetry off for self-hosted users, meaning that the plugin will only send Sentry events to Sentry.io if the URL used in the plugin (i.e. where sourcemaps are uploaded to) is sentry.io. 

Unfortunately, this isn't entirely straight forward. Sentry-CLI will read a config file (`.sentryclirc`) if it finds one. Either in the directory of a global CLI installation (default behaviour) or if a path to a config file was specified via the `configFile` option. At option conversion time, we therefore don't know exactly yet, if the plugin is used for SaaS or self-hosted. We can only check the `url` option and `SENTRY_URL` env variable to make a first decision.

Only at a later time, we can make a call to Sentry-CLI (with the `info`) command which returns us the used Sentry server URL. At this point we can finally definitely make the call to leave telemetry running for SaaS or turn sending off for self-hosted.

Note that I had to remove a call to Sentry for options validation which would until now have sent an error to Sentry in case of a validation error. However, given that this is mostly a user-facing config problem, I think we're not missing out on important data.

Author: Lms24

packages/bundler-plugin-core/src/index.ts

@@ -15,6 +15,7 @@ import {
   addSpanToTransaction,
   captureMinimalError,
   makeSentryClient,
+  turnOffTelemetryForSelfHostedSentry,
 } from "./sentry/telemetry";
 import { Span, Transaction } from "@sentry/types";
 import { createLogger, Logger } from "./sentry/logger";
@@ -108,8 +109,7 @@ const unplugin = createUnplugin<Options>((options, unpluginMetaContext) => {
     handleError(
       new Error("Options were not set correctly. See output above for more details."),
       logger,
-      internalOptions.errorHandler,
-      sentryHub
+      internalOptions.errorHandler
     );
   }
 
@@ -145,6 +145,8 @@ const unplugin = createUnplugin<Options>((options, unpluginMetaContext) => {
      * Responsible for starting the plugin execution transaction and the release injection span
      */
     async buildStart() {
+      await turnOffTelemetryForSelfHostedSentry(cli, sentryHub);
+
       if (!internalOptions.release) {
         internalOptions.release = await cli.releases.proposeVersion();
       }

packages/bundler-plugin-core/src/options-mapping.ts

@@ -58,8 +58,10 @@ export type InternalIncludeEntry = RequiredInternalIncludeEntry &
     ignore: string[];
   };
 
+export const SENTRY_SAAS_URL = "https://sentry.io";
+
 export function normalizeUserOptions(userOptions: UserOptions): InternalOptions {
-  return {
+  const options = {
     // include is the only strictly required option
     // (normalizeInclude needs all userOptions to access top-level include options)
     include: normalizeInclude(userOptions),
@@ -75,6 +77,10 @@ export function normalizeUserOptions(userOptions: UserOptions): InternalOptions
     // Sentry CLI to determine a release if none was specified via options
     // or env vars. In case we don't find one, we'll bail at that point.
     release: userOptions.release ?? process.env["SENTRY_RELEASE"] ?? "",
+    // We technically don't need the URL for anything release-specific
+    // but we want to make sure that we're only sending Sentry data
+    // of SaaS customers. Hence we want to read it anyway.
+    url: userOptions.url ?? process.env["SENTRY_URL"] ?? SENTRY_SAAS_URL,
 
     // Options with default values
     finalize: userOptions.finalize ?? true,
@@ -97,7 +103,6 @@ export function normalizeUserOptions(userOptions: UserOptions): InternalOptions
     customHeader:
       userOptions.customHeader ?? process.env["SENTRY_HEADER"] ?? process.env["CUSTOM_HEADER"],
 
-    url: userOptions.url, // env var: `SENTRY_URL`
     vcsRemote: userOptions.vcsRemote, // env var: `SENTRY_VSC_REMOTE`
 
     // Optional options
@@ -108,6 +113,14 @@ export function normalizeUserOptions(userOptions: UserOptions): InternalOptions
     errorHandler: userOptions.errorHandler,
     configFile: userOptions.configFile,
   };
+
+  // We only want to enable telemetry for SaaS users
+  // This is not the final check (we need to call Sentry CLI at a later point)
+  // but we can already at this point make a first decision.
+  // @see `turnOffTelemetryForSelfHostedSentry` (telemetry.ts) for the second check.
+  options.telemetry = options.telemetry && options.url === SENTRY_SAAS_URL;
+
+  return options;
 }
 
 /**

packages/bundler-plugin-core/src/sentry/cli.ts

@@ -2,7 +2,10 @@ import SentryCli, { SentryCliReleases } from "@sentry/cli";
 import { InternalOptions } from "../options-mapping";
 import { Logger } from "./logger";
 
-type SentryDryRunCLI = { releases: Omit<SentryCliReleases, "listDeploys"> };
+type SentryDryRunCLI = {
+  releases: Omit<SentryCliReleases, "listDeploys">;
+  execute: (args: string[], live: boolean) => Promise<string>;
+};
 export type SentryCLILike = SentryCli | SentryDryRunCLI;
 
 /**
@@ -65,5 +68,9 @@ function getDryRunCLI(cli: SentryCli, logger: Logger): SentryDryRunCLI {
         return Promise.resolve("");
       },
     },
+    execute: (args: string[], live: boolean) => {
+      logger.info("Executing", args, "live:", live);
+      return Promise.resolve("Executed");
+    },
   };
 }

packages/bundler-plugin-core/src/sentry/telemetry.ts

@@ -5,10 +5,11 @@ import {
   makeMain,
   makeNodeTransport,
   NodeClient,
+  Span,
 } from "@sentry/node";
-import { Span } from "@sentry/tracing";
-import { InternalOptions } from "../options-mapping";
+import { InternalOptions, SENTRY_SAAS_URL } from "../options-mapping";
 import { BuildContext } from "../types";
+import { SentryCLILike } from "./cli";
 
 export function makeSentryClient(
   dsn: string,
@@ -119,3 +120,28 @@ export function addPluginOptionTags(options: InternalOptions, hub: Hub) {
 
   hub.setTag("node", process.version);
 }
+
+/**
+ * Makes a call to SentryCLI to get the Sentry server URL the CLI uses.
+ *
+ * We need to check and decide to use telemetry based on the CLI's respone to this call
+ * because only at this time we checked a possibly existing .sentryclirc file. This file
+ * could point to another URL than the default URL.
+ */
+export async function turnOffTelemetryForSelfHostedSentry(cli: SentryCLILike, hub: Hub) {
+  const cliInfo = await cli.execute(["info"], false);
+
+  const url = cliInfo
+    ?.split(/(\r\n|\n|\r)/)[0]
+    ?.replace(/^Sentry Server: /, "")
+    ?.trim();
+
+  if (url !== SENTRY_SAAS_URL) {
+    const client = hub.getClient();
+    if (client) {
+      client.getOptions().enabled = false;
+      client.getOptions().tracesSampleRate = 0;
+      client.getOptions().sampleRate = 0;
+    }
+  }
+}

packages/bundler-plugin-core/test/option-mappings.test.ts

@@ -34,6 +34,7 @@ describe("normalizeUserOptions()", () => {
       silent: false,
       telemetry: true,
       injectReleasesMap: false,
+      url: "https://sentry.io",
     });
   });
 
@@ -76,6 +77,7 @@ describe("normalizeUserOptions()", () => {
       silent: false,
       telemetry: true,
       injectReleasesMap: false,
+      url: "https://sentry.io",
     });
   });
 
@@ -104,6 +106,35 @@ describe("normalizeUserOptions()", () => {
     process.env["SENTRY_HEADER"] = _original_SENTRY_HEADER;
     process.env["CUSTOM_HEADER"] = _original_CUSTOM_HEADER;
   });
+
+  test.each(["https://sentry.io", undefined])(
+    "should enable telemetry if `telemetry` is true and Sentry SaaS URL (%s) is used",
+    (url) => {
+      const options = {
+        include: "",
+        url,
+      };
+
+      expect(normalizeUserOptions(options).telemetry).toBe(true);
+    }
+  );
+
+  test.each([
+    [true, "https://selfhostedSentry.io"],
+    [false, "https://sentry.io"],
+    [false, "https://selfhostedSentry.io"],
+  ])(
+    "should disable telemetry if `telemetry` is %s and Sentry SaaS URL (%s) is used",
+    (telemetry, url) => {
+      const options = {
+        include: "",
+        telemetry,
+        url,
+      };
+
+      expect(normalizeUserOptions(options).telemetry).toBe(false);
+    }
+  );
 });
 
 describe("validateOptions", () => {

packages/bundler-plugin-core/test/sentry/telemetry.test.ts

@@ -1,6 +1,62 @@
 import { Hub } from "@sentry/node";
 import { InternalOptions } from "../../src/options-mapping";
-import { addPluginOptionTags, captureMinimalError } from "../../src/sentry/telemetry";
+import { SentryCLILike } from "../../src/sentry/cli";
+import {
+  addPluginOptionTags,
+  captureMinimalError,
+  turnOffTelemetryForSelfHostedSentry,
+} from "../../src/sentry/telemetry";
+
+describe("turnOffTelemetryForSelfHostedSentry", () => {
+  const mockedCLI = {
+    execute: jest
+      .fn()
+      .mockImplementation(() => "Sentry Server: https://sentry.io  \nsomeotherstuff\netc"),
+  };
+
+  const options = {
+    enabled: true,
+    tracesSampleRate: 1.0,
+    sampleRate: 1.0,
+  };
+
+  const mockedClient = {
+    getOptions: jest.fn().mockImplementation(() => options),
+  };
+  const mockedHub = {
+    getClient: jest.fn().mockImplementation(() => {
+      return mockedClient;
+    }),
+  };
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    mockedCLI.execute.mockImplementation(
+      () => "Sentry Server: https://sentry.io  \nsomeotherstuff\netc"
+    );
+  });
+
+  it("Should turn telemetry off if CLI returns a URL other than sentry.io", async () => {
+    mockedCLI.execute.mockImplementation(
+      () => "Sentry Server: https://selfhostedSentry.io  \nsomeotherstuff\netc"
+    );
+    await turnOffTelemetryForSelfHostedSentry(
+      mockedCLI as unknown as SentryCLILike,
+      mockedHub as unknown as Hub
+    );
+    expect(mockedHub.getClient).toHaveBeenCalledTimes(1);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    expect(mockedHub.getClient().getOptions).toHaveBeenCalledTimes(3);
+  });
+
+  it("Should do nothing if CLI returns sentry.io as a URL", async () => {
+    await turnOffTelemetryForSelfHostedSentry(
+      mockedCLI as unknown as SentryCLILike,
+      mockedHub as unknown as Hub
+    );
+    expect(mockedHub.getClient).not.toHaveBeenCalled();
+  });
+});
 
 describe("captureMinimalError", () => {
   const mockedHub = {

packages/playground/vite.config.smallNodeApp.js

@@ -28,8 +28,8 @@ export default defineConfig({
       ignore: ["!out/vite-smallNodeApp/index.js.map"],
       ignoreFile: ".sentryignore",
       setCommits: {
-        repo: "",
-        commit: "",
+        repo: "someRepo",
+        commit: "someCommit",
         ignoreMissing: true,
       },
       deploy: {