Merge branch 'develop' into feat/node-openai-azure-support

Author: bignoncedric

.size-limit.js

@@ -38,7 +38,7 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/prod/index.js',
     import: createImport('init', 'browserTracingIntegration'),
     gzip: true,
-    limit: '41.5 KB',
+    limit: '42 KB',
   },
   {
     name: '@sentry/browser (incl. Tracing, Profiling)',
@@ -127,7 +127,7 @@ module.exports = [
     import: createImport('init', 'ErrorBoundary', 'reactRouterV6BrowserTracingIntegration'),
     ignore: ['react/jsx-runtime'],
     gzip: true,
-    limit: '43.5 KB',
+    limit: '44 KB',
   },
   // Vue SDK (ESM)
   {
@@ -142,7 +142,7 @@ module.exports = [
     path: 'packages/vue/build/esm/index.js',
     import: createImport('init', 'browserTracingIntegration'),
     gzip: true,
-    limit: '43.3 KB',
+    limit: '44 KB',
   },
   // Svelte SDK (ESM)
   {
@@ -163,7 +163,7 @@ module.exports = [
     name: 'CDN Bundle (incl. Tracing)',
     path: createCDNPath('bundle.tracing.min.js'),
     gzip: true,
-    limit: '42.1 KB',
+    limit: '42.5 KB',
   },
   {
     name: 'CDN Bundle (incl. Tracing, Replay)',
@@ -183,14 +183,14 @@ module.exports = [
     path: createCDNPath('bundle.min.js'),
     gzip: false,
     brotli: false,
-    limit: '80 KB',
+    limit: '82 KB',
   },
   {
     name: 'CDN Bundle (incl. Tracing) - uncompressed',
     path: createCDNPath('bundle.tracing.min.js'),
     gzip: false,
     brotli: false,
-    limit: '125 KB',
+    limit: '127 KB',
   },
   {
     name: 'CDN Bundle (incl. Tracing, Replay) - uncompressed',
@@ -231,7 +231,7 @@ module.exports = [
     import: createImport('init'),
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: true,
-    limit: '51.1 KB',
+    limit: '52 KB',
   },
   // Node SDK (ESM)
   {

dev-packages/e2e-tests/test-applications/cloudflare-astro/astro.config.mjs

@@ -6,7 +6,6 @@ const dsn = process.env.E2E_TEST_DSN;
 
 // https://astro.build/config
 export default defineConfig({
-  output: 'hybrid',
   adapter: cloudflare({
     imageService: 'passthrough',
   }),

dev-packages/e2e-tests/test-applications/cloudflare-astro/package.json

@@ -17,7 +17,7 @@
     "test:assert": "pnpm -v"
   },
   "dependencies": {
-    "@astrojs/cloudflare": "8.1.0",
+    "@astrojs/cloudflare": "12.6.11",
     "@sentry/astro": "latest || *",
     "astro": "5.15.9"
   },

dev-packages/node-integration-tests/suites/public-api/LocalVariables/local-variables-out-of-app-default.js

@@ -0,0 +1,28 @@
+/* eslint-disable no-unused-vars */
+
+const Sentry = require('@sentry/node');
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+
+const externalFunctionFile = require.resolve('./node_modules/out-of-app-function.js');
+
+const { out_of_app_function } = require(externalFunctionFile);
+
+function in_app_function() {
+  const inAppVar = 'in app value';
+  out_of_app_function(`${inAppVar} modified value`);
+}
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  transport: loggingTransport,
+  includeLocalVariables: true,
+});
+
+setTimeout(async () => {
+  try {
+    in_app_function();
+  } catch (e) {
+    Sentry.captureException(e);
+    await Sentry.flush();
+  }
+}, 500);

dev-packages/node-integration-tests/suites/public-api/LocalVariables/local-variables-out-of-app.js

@@ -0,0 +1,33 @@
+/* eslint-disable no-unused-vars */
+
+const Sentry = require('@sentry/node');
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+
+const externalFunctionFile = require.resolve('./node_modules/out-of-app-function.js');
+
+const { out_of_app_function } = require(externalFunctionFile);
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  transport: loggingTransport,
+  includeLocalVariables: true,
+  integrations: [
+    Sentry.localVariablesIntegration({
+      includeOutOfAppFrames: true,
+    }),
+  ],
+});
+
+function in_app_function() {
+  const inAppVar = 'in app value';
+  out_of_app_function(`${inAppVar} modified value`);
+}
+
+setTimeout(async () => {
+  try {
+    in_app_function();
+  } catch (e) {
+    Sentry.captureException(e);
+    await Sentry.flush();
+  }
+}, 500);

dev-packages/node-integration-tests/suites/public-api/LocalVariables/test.ts

@@ -1,5 +1,6 @@
+import { mkdirSync, rmdirSync, unlinkSync, writeFileSync } from 'fs';
 import * as path from 'path';
-import { afterAll, describe, expect, test } from 'vitest';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 import { conditionalTest } from '../../../utils';
 import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
 
@@ -39,8 +40,35 @@ const EXPECTED_LOCAL_VARIABLES_EVENT = {
 };
 
 describe('LocalVariables integration', () => {
+  const nodeModules = `${__dirname}/node_modules`;
+  const externalModule = `${nodeModules}//out-of-app-function.js`;
+  function cleanupExternalModuleFile() {
+    try {
+      unlinkSync(externalModule);
+      // eslint-disable-next-line no-empty
+    } catch {}
+    try {
+      rmdirSync(nodeModules);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  beforeAll(() => {
+    cleanupExternalModuleFile();
+    mkdirSync(nodeModules, { recursive: true });
+    writeFileSync(
+      externalModule,
+      `
+function out_of_app_function(passedArg) {
+  const outOfAppVar = "out of app value " + passedArg.substring(13);
+  throw new Error("out-of-app error");
+}
+module.exports = { out_of_app_function };`,
+    );
+  });
   afterAll(() => {
     cleanupChildProcesses();
+    cleanupExternalModuleFile();
   });
 
   test('Should not include local variables by default', async () => {
@@ -127,4 +155,47 @@ describe('LocalVariables integration', () => {
       .start()
       .completed();
   });
+
+  test('adds local variables to out of app frames when includeOutOfAppFrames is true', async () => {
+    await createRunner(__dirname, 'local-variables-out-of-app.js')
+      .expect({
+        event: event => {
+          const frames = event.exception?.values?.[0]?.stacktrace?.frames || [];
+
+          const inAppFrame = frames.find(frame => frame.function === 'in_app_function');
+          const outOfAppFrame = frames.find(frame => frame.function === 'out_of_app_function');
+
+          expect(inAppFrame?.vars).toEqual({ inAppVar: 'in app value' });
+          expect(inAppFrame?.in_app).toEqual(true);
+
+          expect(outOfAppFrame?.vars).toEqual({
+            outOfAppVar: 'out of app value modified value',
+            passedArg: 'in app value modified value',
+          });
+          expect(outOfAppFrame?.in_app).toEqual(false);
+        },
+      })
+      .start()
+      .completed();
+  });
+
+  test('does not add local variables to out of app frames by default', async () => {
+    await createRunner(__dirname, 'local-variables-out-of-app-default.js')
+      .expect({
+        event: event => {
+          const frames = event.exception?.values?.[0]?.stacktrace?.frames || [];
+
+          const inAppFrame = frames.find(frame => frame.function === 'in_app_function');
+          const outOfAppFrame = frames.find(frame => frame.function === 'out_of_app_function');
+
+          expect(inAppFrame?.vars).toEqual({ inAppVar: 'in app value' });
+          expect(inAppFrame?.in_app).toEqual(true);
+
+          expect(outOfAppFrame?.vars).toBeUndefined();
+          expect(outOfAppFrame?.in_app).toEqual(false);
+        },
+      })
+      .start()
+      .completed();
+  });
 });

packages/core/src/attributes.ts

@@ -0,0 +1,141 @@
+import { DEBUG_BUILD } from './debug-build';
+import type { DurationUnit, FractionUnit, InformationUnit } from './types-hoist/measurement';
+import { debug } from './utils/debug-logger';
+
+export type RawAttributes<T> = T & ValidatedAttributes<T>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type RawAttribute<T> = T extends { value: any } | { unit: any } ? AttributeObject : T;
+
+export type Attributes = Record<string, TypedAttributeValue>;
+
+export type AttributeValueType = string | number | boolean | Array<string> | Array<number> | Array<boolean>;
+
+type AttributeTypeMap = {
+  string: string;
+  integer: number;
+  double: number;
+  boolean: boolean;
+  'string[]': Array<string>;
+  'integer[]': Array<number>;
+  'double[]': Array<number>;
+  'boolean[]': Array<boolean>;
+};
+
+/* Generates a type from the AttributeTypeMap like:
+  | { value: string; type: 'string' }
+  | { value: number; type: 'integer' }
+  | { value: number; type: 'double' }
+ */
+type AttributeUnion = {
+  [K in keyof AttributeTypeMap]: {
+    value: AttributeTypeMap[K];
+    type: K;
+  };
+}[keyof AttributeTypeMap];
+
+export type TypedAttributeValue = AttributeUnion & { unit?: AttributeUnit };
+
+export type AttributeObject = {
+  value: unknown;
+  unit?: AttributeUnit;
+};
+
+// Unfortunately, we loose type safety if we did something like Exclude<MeasurementUnit, string>
+// so therefore we unionize between the three supported unit categories.
+type AttributeUnit = DurationUnit | InformationUnit | FractionUnit;
+
+/* If an attribute has either a 'value' or 'unit' property, we use the ValidAttributeObject type. */
+export type ValidatedAttributes<T> = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [K in keyof T]: T[K] extends { value: any } | { unit: any } ? AttributeObject : unknown;
+};
+
+/**
+ * Type-guard: The attribute object has the shape the official attribute object (value, type, unit).
+ * https://develop.sentry.dev/sdk/telemetry/scopes/#setting-attributes
+ */
+export function isAttributeObject(maybeObj: unknown): maybeObj is AttributeObject {
+  return (
+    typeof maybeObj === 'object' &&
+    maybeObj != null &&
+    !Array.isArray(maybeObj) &&
+    Object.keys(maybeObj).includes('value')
+  );
+}
+
+/**
+ * Converts an attribute value to a typed attribute value.
+ *
+ * Does not allow mixed arrays. In case of a mixed array, the value is stringified and the type is 'string'.
+ * All values besides the supported attribute types (see {@link AttributeTypeMap}) are stringified to a string attribute value.
+ *
+ * @param value - The value of the passed attribute.
+ * @returns The typed attribute.
+ */
+export function attributeValueToTypedAttributeValue(rawValue: unknown): TypedAttributeValue {
+  const { value, unit } = isAttributeObject(rawValue) ? rawValue : { value: rawValue, unit: undefined };
+  return { ...getTypedAttributeValue(value), ...(unit && typeof unit === 'string' ? { unit } : {}) };
+}
+
+// Only allow string, boolean, or number types
+const getPrimitiveType: (
+  item: unknown,
+) => keyof Pick<AttributeTypeMap, 'string' | 'integer' | 'double' | 'boolean'> | null = item =>
+  typeof item === 'string'
+    ? 'string'
+    : typeof item === 'boolean'
+      ? 'boolean'
+      : typeof item === 'number' && !Number.isNaN(item)
+        ? Number.isInteger(item)
+          ? 'integer'
+          : 'double'
+        : null;
+
+function getTypedAttributeValue(value: unknown): TypedAttributeValue {
+  const primitiveType = getPrimitiveType(value);
+  if (primitiveType) {
+    // @ts-expect-error - TS complains because {@link TypedAttributeValue} is strictly typed to
+    // avoid setting the wrong `type` on the attribute value.
+    // In this case, getPrimitiveType already does the check but TS doesn't know that.
+    // The "clean" alternative is to return an object per `typeof value` case
+    // but that would require more bundle size
+    // Therefore, we ignore it.
+    return { value, type: primitiveType };
+  }
+
+  if (Array.isArray(value)) {
+    const coherentArrayType = value.reduce((acc: 'string' | 'boolean' | 'integer' | 'double' | null, item) => {
+      if (!acc || getPrimitiveType(item) !== acc) {
+        return null;
+      }
+      return acc;
+    }, getPrimitiveType(value[0]));
+
+    if (coherentArrayType) {
+      return { value, type: `${coherentArrayType}[]` };
+    }
+  }
+
+  // Fallback: stringify the passed value
+  let fallbackValue = '';
+  try {
+    fallbackValue = JSON.stringify(value) ?? String(value);
+  } catch {
+    try {
+      fallbackValue = String(value);
+    } catch {
+      DEBUG_BUILD && debug.warn('Failed to stringify attribute value', value);
+      // ignore
+    }
+  }
+
+  // This is quite a low-quality message but we cannot safely log the original `value`
+  // here due to String() or JSON.stringify() potentially throwing.
+  DEBUG_BUILD &&
+    debug.log(`Stringified attribute value to ${fallbackValue} because it's not a supported attribute value type`);
+
+  return {
+    value: fallbackValue,
+    type: 'string',
+  };
+}