@spotlightjs/spotlight 4.3.0 → 4.4.0

package/bin/instrument.js

@@ -1,4 +1,56 @@
-import { init, flush, consoleLoggingIntegration } from "@sentry/node";
+import { consoleLoggingIntegration, getClient, init } from "@sentry/node";
+import { parseCLIArgs } from "@spotlightjs/sidecar/cli";
+import { DEFAULT_PORT } from "@spotlightjs/sidecar/constants";
+
+// Parse CLI arguments to determine the port this Spotlight instance will use
+const { port: instancePort } = parseCLIArgs();
+
+// Check if SENTRY_SPOTLIGHT points to this instance
+const spotlightEnv = process.env.SENTRY_SPOTLIGHT;
+let disableSpotlight = false;
+
+// Note: If port is set to 0 (dynamic port assignment), we cannot detect the actual port
+// before starting the server, so we cannot prevent the feedback loop in that case.
+// The server will be assigned a port by the OS after it starts, and if SENTRY_SPOTLIGHT
+// happens to point to that same port, a feedback loop may occur.
+if (spotlightEnv && instancePort !== 0) {
+  let targetPort;
+  let targetHost;
+
+  // SENTRY_SPOTLIGHT can be:
+  // 1. A full URL like "http://localhost:8969"
+  // 2. A truthy value (true, t, y, yes, on, 1) which means use the default URL
+  const TRUTHY_ENV_VALUES = new Set(["true", "t", "y", "yes", "on", "1"]);
+  const isTruthy = TRUTHY_ENV_VALUES.has(spotlightEnv.toLowerCase());
+
+  if (isTruthy) {
+    // Use default Spotlight URL
+    targetHost = "localhost";
+    targetPort = DEFAULT_PORT;
+  } else {
+    // Try to parse as URL
+    try {
+      const spotlightUrl = new URL(spotlightEnv);
+      targetHost = spotlightUrl.hostname;
+      targetPort = spotlightUrl.port ? Number(spotlightUrl.port) : spotlightUrl.protocol === "https:" ? 443 : 80;
+    } catch (_err) {
+      // If we can't parse it, we can't determine if it's a feedback loop, so do nothing
+      targetPort = null;
+    }
+  }
+
+  // Only disable if we successfully determined the target and it matches our instance
+  if (targetPort !== null && targetPort !== undefined) {
+    const isLocalhost = targetHost === "localhost" || targetHost === "127.0.0.1" || targetHost === "::1";
+
+    if (isLocalhost && targetPort === instancePort) {
+      disableSpotlight = true;
+      console.warn(
+        `⚠️  [Spotlight] SENTRY_SPOTLIGHT is set to ${spotlightEnv} which points to this Spotlight instance (port ${instancePort}). Disabling Spotlight integration to prevent feedback loop.`,
+      );
+    }
+  }
+}
 
 const sentry = init({
   dsn: "https://51bcd92dba1128934afd1c5726c84442@o1.ingest.us.sentry.io/4508404727283713",
@@ -8,6 +60,7 @@ const sentry = init({
 
   tracesSampleRate: 1,
   enableLogs: true,
+  ...(disableSpotlight && { spotlight: false }),
 
   integrations: [
     consoleLoggingIntegration({
@@ -15,12 +68,12 @@ const sentry = init({
     }),
   ],
 
-  beforeSendTransaction: (event) => {
+  beforeSendTransaction: event => {
     event.server_name = undefined; // Server name might contain PII
     return event;
   },
 
-  beforeSend: (event) => {
+  beforeSend: event => {
     const exceptions = event.exception?.values;
     if (!exceptions) {
       return event;

package/bin/run.js

@@ -20,55 +20,44 @@ const homeDir = process.env.HOME || process.env.USERPROFILE;
 setContext("CLI", {
   sea: sea.isSea(),
   // TODO: Be less naive with path obscuring
-  argv: process.argv.map((arg) => arg.replace(homeDir, "~")),
+  argv: process.argv.map(arg => arg.replace(homeDir, "~")),
 });
 
 const withTracing =
   (fn, spanArgs = {}) =>
   (...args) =>
-    startSpan({ name: fn.name, attributes: { args }, ...spanArgs }, () =>
-      fn(...args)
-    );
+    startSpan({ name: fn.name, attributes: { args }, ...spanArgs }, () => fn(...args));
 
 const readAsset = withTracing(
   sea.isSea()
-    ? (name) => Buffer.from(sea.getRawAsset(name))
+    ? name => Buffer.from(sea.getRawAsset(name))
     : (() => {
-        const ASSET_DIR = join(
-          fileURLToPath(import.meta.url),
-          "../../dist/overlay/"
-        );
+        const ASSET_DIR = join(fileURLToPath(import.meta.url), "../../dist/overlay/");
 
-        return (name) => readFileSync(join(ASSET_DIR, name));
+        return name => readFileSync(join(ASSET_DIR, name));
       })(),
-  { name: "readAsset", op: "cli.asset.read" }
+  { name: "readAsset", op: "cli.asset.read" },
 );
 
 startSpan({ name: "Spotlight CLI", op: "cli" }, async () => {
-  await startSpan(
-    { name: "Setup Sidecar", op: "cli.setup.sidecar" },
-    async () => {
-      const MANIFEST_NAME = "manifest.json";
-      const ENTRY_POINT_NAME = "src/index.html";
-      const filesToServe = Object.create(null);
+  await startSpan({ name: "Setup Sidecar", op: "cli.setup.sidecar" }, async () => {
+    const MANIFEST_NAME = "manifest.json";
+    const ENTRY_POINT_NAME = "src/index.html";
+    const filesToServe = Object.create(null);
 
-      startSpan(
-        { name: "Setup Server Assets", op: "cli.setup.sidecar.assets" },
-        () => {
-          // Following the guide here: https://vite.dev/guide/backend-integration.html
-          const manifest = JSON.parse(readAsset(MANIFEST_NAME));
-          filesToServe[ENTRY_POINT_NAME] = readAsset(ENTRY_POINT_NAME);
-          const entries = Object.values(manifest);
-          for (const entry of entries) {
-            filesToServe[entry.file] = readAsset(entry.file);
-          }
-        }
-      );
+    startSpan({ name: "Setup Server Assets", op: "cli.setup.sidecar.assets" }, () => {
+      // Following the guide here: https://vite.dev/guide/backend-integration.html
+      const manifest = JSON.parse(readAsset(MANIFEST_NAME));
+      filesToServe[ENTRY_POINT_NAME] = readAsset(ENTRY_POINT_NAME);
+      const entries = Object.values(manifest);
+      for (const entry of entries) {
+        filesToServe[entry.file] = readAsset(entry.file);
+      }
+    });
 
-      await main({
-        basePath: process.cwd(),
-        filesToServe,
-      });
-    }
-  );
+    await main({
+      basePath: process.cwd(),
+      filesToServe,
+    });
+  });
 });