feat(core): Allow to specify depth to dropUndefinedKeys

mydea · mydea · commit 9e7b55dacab5 · 2025-03-21T12:50:44.000+01:00
diff --git a/packages/astro/src/integration/index.ts b/packages/astro/src/integration/index.ts
@@ -3,7 +3,7 @@ import * as path from 'path';
 import { sentryVitePlugin } from '@sentry/vite-plugin';
 import type { AstroConfig, AstroIntegration } from 'astro';
 
-import { consoleSandbox, dropUndefinedKeys } from '@sentry/core';
+import { consoleSandbox } from '@sentry/core';
 import { buildClientSnippet, buildSdkInitFileImportSnippet, buildServerSnippet } from './snippets';
 import type { SentryOptions } from './types';
 
@@ -62,34 +62,32 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
                 sourcemap: computedSourceMapSettings.updatedSourceMapSetting,
               },
               plugins: [
-                sentryVitePlugin(
-                  dropUndefinedKeys({
-                    org: uploadOptions.org ?? env.SENTRY_ORG,
-                    project: uploadOptions.project ?? env.SENTRY_PROJECT,
-                    authToken: uploadOptions.authToken ?? env.SENTRY_AUTH_TOKEN,
-                    telemetry: uploadOptions.telemetry ?? true,
-                    _metaOptions: {
-                      telemetry: {
-                        metaFramework: 'astro',
-                      },
+                sentryVitePlugin({
+                  org: uploadOptions.org ?? env.SENTRY_ORG,
+                  project: uploadOptions.project ?? env.SENTRY_PROJECT,
+                  authToken: uploadOptions.authToken ?? env.SENTRY_AUTH_TOKEN,
+                  telemetry: uploadOptions.telemetry ?? true,
+                  _metaOptions: {
+                    telemetry: {
+                      metaFramework: 'astro',
                     },
-                    ...unstable_sentryVitePluginOptions,
-                    debug: options.debug ?? false,
-                    sourcemaps: {
-                      assets: uploadOptions.assets ?? [getSourcemapsAssetsGlob(config)],
-                      filesToDeleteAfterUpload:
-                        uploadOptions?.filesToDeleteAfterUpload ?? updatedFilesToDeleteAfterUpload,
-                      ...unstable_sentryVitePluginOptions?.sourcemaps,
-                    },
-                    bundleSizeOptimizations: {
-                      ...options.bundleSizeOptimizations,
-                      // TODO: with a future version of the vite plugin (probably 2.22.0) this re-mapping is not needed anymore
-                      // ref: https://github.com/getsentry/sentry-javascript-bundler-plugins/pull/582
-                      excludePerformanceMonitoring: options.bundleSizeOptimizations?.excludeTracing,
-                      ...unstable_sentryVitePluginOptions?.bundleSizeOptimizations,
-                    },
-                  }),
-                ),
+                  },
+                  ...unstable_sentryVitePluginOptions,
+                  debug: options.debug ?? false,
+                  sourcemaps: {
+                    assets: uploadOptions.assets ?? [getSourcemapsAssetsGlob(config)],
+                    filesToDeleteAfterUpload:
+                      uploadOptions?.filesToDeleteAfterUpload ?? updatedFilesToDeleteAfterUpload,
+                    ...unstable_sentryVitePluginOptions?.sourcemaps,
+                  },
+                  bundleSizeOptimizations: {
+                    ...options.bundleSizeOptimizations,
+                    // TODO: with a future version of the vite plugin (probably 2.22.0) this re-mapping is not needed anymore
+                    // ref: https://github.com/getsentry/sentry-javascript-bundler-plugins/pull/582
+                    excludePerformanceMonitoring: options.bundleSizeOptimizations?.excludeTracing,
+                    ...unstable_sentryVitePluginOptions?.bundleSizeOptimizations,
+                  },
+                }),
               ],
             },
           });
diff --git a/packages/core/src/tracing/sentrySpan.ts b/packages/core/src/tracing/sentrySpan.ts
@@ -223,24 +223,27 @@ export class SentrySpan implements Span {
    * use `spanToJSON(span)` instead.
    */
   public getSpanJSON(): SpanJSON {
-    return dropUndefinedKeys({
-      data: this._attributes,
-      description: this._name,
-      op: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],
-      parent_span_id: this._parentSpanId,
-      span_id: this._spanId,
-      start_timestamp: this._startTime,
-      status: getStatusMessage(this._status),
-      timestamp: this._endTime,
-      trace_id: this._traceId,
-      origin: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined,
-      profile_id: this._attributes[SEMANTIC_ATTRIBUTE_PROFILE_ID] as string | undefined,
-      exclusive_time: this._attributes[SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME] as number | undefined,
-      measurements: timedEventsToMeasurements(this._events),
-      is_segment: (this._isStandaloneSpan && getRootSpan(this) === this) || undefined,
-      segment_id: this._isStandaloneSpan ? getRootSpan(this).spanContext().spanId : undefined,
-      links: convertSpanLinksForEnvelope(this._links),
-    });
+    return dropUndefinedKeys(
+      {
+        data: this._attributes,
+        description: this._name,
+        op: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],
+        parent_span_id: this._parentSpanId,
+        span_id: this._spanId,
+        start_timestamp: this._startTime,
+        status: getStatusMessage(this._status),
+        timestamp: this._endTime,
+        trace_id: this._traceId,
+        origin: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined,
+        profile_id: this._attributes[SEMANTIC_ATTRIBUTE_PROFILE_ID] as string | undefined,
+        exclusive_time: this._attributes[SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME] as number | undefined,
+        measurements: timedEventsToMeasurements(this._events),
+        is_segment: (this._isStandaloneSpan && getRootSpan(this) === this) || undefined,
+        segment_id: this._isStandaloneSpan ? getRootSpan(this).spanContext().spanId : undefined,
+        links: convertSpanLinksForEnvelope(this._links),
+      },
+      1,
+    );
   }
 
   /** @inheritdoc */
diff --git a/packages/core/src/utils-hoist/object.ts b/packages/core/src/utils-hoist/object.ts
@@ -211,17 +211,22 @@ export function extractExceptionKeysForMessage(exception: Record<string, unknown
  *
  * Attention: This function keeps circular references in the returned object.
  */
-export function dropUndefinedKeys<T>(inputValue: T): T {
+export function dropUndefinedKeys<T>(inputValue: T, depth = Infinity): T {
   // This map keeps track of what already visited nodes map to.
   // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular
   // references as the input object.
   const memoizationMap = new Map<unknown, unknown>();
 
   // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API
-  return _dropUndefinedKeys(inputValue, memoizationMap);
+  return _dropUndefinedKeys(inputValue, memoizationMap, depth);
 }
 
-function _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unknown>): T {
+function _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unknown>, depth: number): T {
+  // If the max. depth is reached, return the input value as is
+  if (!depth) {
+    return inputValue;
+  }
+
   if (isPojo(inputValue)) {
     // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object
     const memoVal = memoizationMap.get(inputValue);
@@ -235,7 +240,7 @@ function _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unkno
 
     for (const key of Object.getOwnPropertyNames(inputValue)) {
       if (typeof inputValue[key] !== 'undefined') {
-        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);
+        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap, depth - 1);
       }
     }
 
@@ -254,7 +259,7 @@ function _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unkno
     memoizationMap.set(inputValue, returnValue);
 
     inputValue.forEach((item: unknown) => {
-      returnValue.push(_dropUndefinedKeys(item, memoizationMap));
+      returnValue.push(_dropUndefinedKeys(item, memoizationMap, depth - 1));
     });
 
     return returnValue as unknown as T;
diff --git a/packages/core/src/utils/request.ts b/packages/core/src/utils/request.ts
@@ -91,14 +91,17 @@ export function httpRequestToRequestData(request: {
   // This is non-standard, but may be set on e.g. Next.js or Express requests
   const cookies = (request as PolymorphicRequest).cookies;
 
-  return dropUndefinedKeys({
-    url: absoluteUrl,
-    method: request.method,
-    query_string: extractQueryParamsFromUrl(url),
-    headers: headersToDict(headers),
-    cookies,
-    data,
-  });
+  return dropUndefinedKeys(
+    {
+      url: absoluteUrl,
+      method: request.method,
+      query_string: extractQueryParamsFromUrl(url),
+      headers: headersToDict(headers),
+      cookies,
+      data,
+    },
+    1,
+  );
 }
 
 function getAbsoluteUrl({
diff --git a/packages/core/src/utils/spanUtils.ts b/packages/core/src/utils/spanUtils.ts
@@ -42,16 +42,19 @@ export function spanToTransactionTraceContext(span: Span): TraceContext {
   const { spanId: span_id, traceId: trace_id } = span.spanContext();
   const { data, op, parent_span_id, status, origin, links } = spanToJSON(span);
 
-  return dropUndefinedKeys({
-    parent_span_id,
-    span_id,
-    trace_id,
-    data,
-    op,
-    status,
-    origin,
-    links,
-  });
+  return dropUndefinedKeys(
+    {
+      parent_span_id,
+      span_id,
+      trace_id,
+      data,
+      op,
+      status,
+      origin,
+      links,
+    },
+    1,
+  );
 }
 
 /**
@@ -147,20 +150,23 @@ export function spanToJSON(span: Span): SpanJSON {
   if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
     const { attributes, startTime, name, endTime, parentSpanId, status, links } = span;
 
-    return dropUndefinedKeys({
-      span_id,
-      trace_id,
-      data: attributes,
-      description: name,
-      parent_span_id: parentSpanId,
-      start_timestamp: spanTimeInputToSeconds(startTime),
-      // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
-      timestamp: spanTimeInputToSeconds(endTime) || undefined,
-      status: getStatusMessage(status),
-      op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],
-      origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined,
-      links: convertSpanLinksForEnvelope(links),
-    });
+    return dropUndefinedKeys(
+      {
+        span_id,
+        trace_id,
+        data: attributes,
+        description: name,
+        parent_span_id: parentSpanId,
+        start_timestamp: spanTimeInputToSeconds(startTime),
+        // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
+        timestamp: spanTimeInputToSeconds(endTime) || undefined,
+        status: getStatusMessage(status),
+        op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],
+        origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined,
+        links: convertSpanLinksForEnvelope(links),
+      },
+      1,
+    );
   }
 
   // Finally, at least we have `spanContext()`....
diff --git a/packages/core/test/utils-hoist/object.test.ts b/packages/core/test/utils-hoist/object.test.ts
@@ -208,6 +208,33 @@ describe('dropUndefinedKeys()', () => {
     });
   });
 
+  test('arrays with depth=1', () => {
+    expect(
+      dropUndefinedKeys(
+        {
+          a: [
+            1,
+            undefined,
+            {
+              a: 1,
+              b: undefined,
+            },
+          ],
+        },
+        1,
+      ),
+    ).toStrictEqual({
+      a: [
+        1,
+        undefined,
+        {
+          a: 1,
+          b: undefined,
+        },
+      ],
+    });
+  });
+
   test('nested objects', () => {
     expect(
       dropUndefinedKeys({
@@ -232,6 +259,65 @@ describe('dropUndefinedKeys()', () => {
     });
   });
 
+  test('nested objects with depth=1', () => {
+    expect(
+      dropUndefinedKeys(
+        {
+          a: 1,
+          b: {
+            c: 2,
+            d: undefined,
+            e: {
+              f: 3,
+              g: undefined,
+            },
+          },
+          c: undefined,
+        },
+        1,
+      ),
+    ).toStrictEqual({
+      a: 1,
+      b: {
+        c: 2,
+        d: undefined,
+        e: {
+          f: 3,
+          g: undefined,
+        },
+      },
+    });
+  });
+
+  test('nested objects with depth=2', () => {
+    expect(
+      dropUndefinedKeys(
+        {
+          a: 1,
+          b: {
+            c: 2,
+            d: undefined,
+            e: {
+              f: 3,
+              g: undefined,
+            },
+          },
+          c: undefined,
+        },
+        2,
+      ),
+    ).toStrictEqual({
+      a: 1,
+      b: {
+        c: 2,
+        e: {
+          f: 3,
+          g: undefined,
+        },
+      },
+    });
+  });
+
   describe('class instances', () => {
     class MyClass {
       public a = 'foo';
diff --git a/packages/replay-internal/src/integration.ts b/packages/replay-internal/src/integration.ts
@@ -356,7 +356,7 @@ function loadReplayOptionsFromClient(initialOptions: InitialReplayPluginOptions,
   const finalOptions: ReplayPluginOptions = {
     sessionSampleRate: 0,
     errorSampleRate: 0,
-    ...dropUndefinedKeys(initialOptions),
+    ...dropUndefinedKeys(initialOptions, 1),
   };
 
   const replaysSessionSampleRate = parseSampleRate(opt.replaysSessionSampleRate);
