@sentry/core 10.47.0 → 10.48.0

package/build/esm/tracing/spans/beforeSendSpan.js

@@ -0,0 +1,40 @@
+import { addNonEnumerableProperty } from '../../utils/object.js';
+
+/**
+ * A wrapper to use the new span format in your `beforeSendSpan` callback.
+ *
+ * When using `traceLifecycle: 'stream'`, wrap your callback with this function
+ * to receive and return {@link StreamedSpanJSON} instead of the standard {@link SpanJSON}.
+ *
+ * @example
+ *
+ * Sentry.init({
+ *   traceLifecycle: 'stream',
+ *   beforeSendSpan: withStreamedSpan((span) => {
+ *     // span is of type StreamedSpanJSON
+ *     return span;
+ *   }),
+ * });
+ *
+ * @param callback - The callback function that receives and returns a {@link StreamedSpanJSON}.
+ * @returns A callback that is compatible with the `beforeSendSpan` option when using `traceLifecycle: 'stream'`.
+ */
+function withStreamedSpan(
+  callback,
+) {
+  addNonEnumerableProperty(callback, '_streamed', true);
+  return callback ;
+}
+
+/**
+ * Typesafe check to identify if a `beforeSendSpan` callback expects the streamed span JSON format.
+ *
+ * @param callback - The `beforeSendSpan` callback to check.
+ * @returns `true` if the callback was wrapped with {@link withStreamedSpan}.
+ */
+function isStreamedBeforeSendSpanCallback(callback) {
+  return !!callback && typeof callback === 'function' && '_streamed' in callback && !!callback._streamed;
+}
+
+export { isStreamedBeforeSendSpanCallback, withStreamedSpan };
+//# sourceMappingURL=beforeSendSpan.js.map

package/build/esm/tracing/spans/beforeSendSpan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"beforeSendSpan.js","sources":["../../../../src/tracing/spans/beforeSendSpan.ts"],"sourcesContent":["import type { CoreOptions } from '../../types-hoist/options';\nimport type { BeforeSendStreamedSpanCallback } from '../../types-hoist/options';\nimport type { StreamedSpanJSON } from '../../types-hoist/span';\nimport { addNonEnumerableProperty } from '../../utils/object';\n\ntype StaticBeforeSendSpanCallback = CoreOptions['beforeSendSpan'];\n\n/**\n * A wrapper to use the new span format in your `beforeSendSpan` callback.\n *\n * When using `traceLifecycle: 'stream'`, wrap your callback with this function\n * to receive and return {@link StreamedSpanJSON} instead of the standard {@link SpanJSON}.\n *\n * @example\n *\n * Sentry.init({\n *   traceLifecycle: 'stream',\n *   beforeSendSpan: withStreamedSpan((span) => {\n *     // span is of type StreamedSpanJSON\n *     return span;\n *   }),\n * });\n *\n * @param callback - The callback function that receives and returns a {@link StreamedSpanJSON}.\n * @returns A callback that is compatible with the `beforeSendSpan` option when using `traceLifecycle: 'stream'`.\n */\nexport function withStreamedSpan(\n  callback: (span: StreamedSpanJSON) => StreamedSpanJSON,\n): StaticBeforeSendSpanCallback & { _streamed: true } {\n  addNonEnumerableProperty(callback, '_streamed', true);\n  return callback as unknown as StaticBeforeSendSpanCallback & { _streamed: true };\n}\n\n/**\n * Typesafe check to identify if a `beforeSendSpan` callback expects the streamed span JSON format.\n *\n * @param callback - The `beforeSendSpan` callback to check.\n * @returns `true` if the callback was wrapped with {@link withStreamedSpan}.\n */\nexport function isStreamedBeforeSendSpanCallback(callback: unknown): callback is BeforeSendStreamedSpanCallback {\n  return !!callback && typeof callback === 'function' && '_streamed' in callback && !!callback._streamed;\n}\n"],"names":[],"mappings":";;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,gBAAgB;AAChC,EAAE,QAAQ;AACV,EAAsD;AACtD,EAAE,wBAAwB,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,CAAC;AACvD,EAAE,OAAO,QAAA;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,gCAAgC,CAAC,QAAQ,EAAuD;AAChH,EAAE,OAAO,CAAC,CAAC,YAAY,OAAO,aAAa,UAAA,IAAc,WAAA,IAAe,QAAA,IAAY,CAAC,CAAC,QAAQ,CAAC,SAAS;AACxG;;;;"}

package/build/esm/tracing/spans/captureSpan.js

@@ -0,0 +1,122 @@
+import { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_USER_USERNAME, SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS, SEMANTIC_ATTRIBUTE_USER_EMAIL, SEMANTIC_ATTRIBUTE_USER_ID, SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME, SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID, SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME, SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT, SEMANTIC_ATTRIBUTE_SENTRY_RELEASE } from '../../semanticAttributes.js';
+import { getCombinedScopeData } from '../../utils/scopeData.js';
+import { spanToStreamedSpanJSON, INTERNAL_getSegmentSpan, streamedSpanJsonToSerializedSpan, showSpanDropWarning } from '../../utils/spanUtils.js';
+import { getCapturedScopesOnSpan } from '../utils.js';
+import { isStreamedBeforeSendSpanCallback } from './beforeSendSpan.js';
+
+/**
+ * Captures a span and returns a JSON representation to be enqueued for sending.
+ *
+ * IMPORTANT: This function converts the span to JSON immediately to avoid writing
+ * to an already-ended OTel span instance (which is blocked by the OTel Span class).
+ *
+ * @returns the final serialized span with a reference to its segment span. This reference
+ * is needed later on to compute the DSC for the span envelope.
+ */
+function captureSpan(span, client) {
+  // Convert to JSON FIRST - we cannot write to an already-ended span
+  const spanJSON = spanToStreamedSpanJSON(span);
+
+  const segmentSpan = INTERNAL_getSegmentSpan(span);
+  const serializedSegmentSpan = spanToStreamedSpanJSON(segmentSpan);
+
+  const { isolationScope: spanIsolationScope, scope: spanScope } = getCapturedScopesOnSpan(span);
+
+  const finalScopeData = getCombinedScopeData(spanIsolationScope, spanScope);
+
+  applyCommonSpanAttributes(spanJSON, serializedSegmentSpan, client, finalScopeData);
+
+  if (spanJSON.is_segment) {
+    // Allow hook subscribers to mutate the segment span JSON
+    client.emit('processSegmentSpan', spanJSON);
+  }
+
+  // Allow hook subscribers to mutate the span JSON
+  client.emit('processSpan', spanJSON);
+
+  const { beforeSendSpan } = client.getOptions();
+  const processedSpan =
+    beforeSendSpan && isStreamedBeforeSendSpanCallback(beforeSendSpan)
+      ? applyBeforeSendSpanCallback(spanJSON, beforeSendSpan)
+      : spanJSON;
+
+  // Backfill sentry.span.source from sentry.source. Only `sentry.span.source` is respected by Sentry.
+  // TODO(v11): Remove this backfill once we renamed SEMANTIC_ATTRIBUTE_SENTRY_SOURCE to sentry.span.source
+  const spanNameSource = processedSpan.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
+  if (spanNameSource) {
+    safeSetSpanJSONAttributes(processedSpan, {
+      // Purposefully not using a constant defined here like in other attributes:
+      // This will be the name for SEMANTIC_ATTRIBUTE_SENTRY_SOURCE in v11
+      'sentry.span.source': spanNameSource,
+    });
+  }
+
+  return {
+    ...streamedSpanJsonToSerializedSpan(processedSpan),
+    _segmentSpan: segmentSpan,
+  };
+}
+
+function applyCommonSpanAttributes(
+  spanJSON,
+  serializedSegmentSpan,
+  client,
+  scopeData,
+) {
+  const sdk = client.getSdkMetadata();
+  const { release, environment, sendDefaultPii } = client.getOptions();
+
+  // avoid overwriting any previously set attributes (from users or potentially our SDK instrumentation)
+  safeSetSpanJSONAttributes(spanJSON, {
+    [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: release,
+    [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: environment,
+    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: serializedSegmentSpan.name,
+    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]: serializedSegmentSpan.span_id,
+    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]: sdk?.sdk?.name,
+    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]: sdk?.sdk?.version,
+    ...(sendDefaultPii
+      ? {
+          [SEMANTIC_ATTRIBUTE_USER_ID]: scopeData.user?.id,
+          [SEMANTIC_ATTRIBUTE_USER_EMAIL]: scopeData.user?.email,
+          [SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]: scopeData.user?.ip_address,
+          [SEMANTIC_ATTRIBUTE_USER_USERNAME]: scopeData.user?.username,
+        }
+      : {}),
+    ...scopeData.attributes,
+  });
+}
+
+/**
+ * Apply a user-provided beforeSendSpan callback to a span JSON.
+ */
+function applyBeforeSendSpanCallback(
+  span,
+  beforeSendSpan,
+) {
+  const modifedSpan = beforeSendSpan(span);
+  if (!modifedSpan) {
+    showSpanDropWarning();
+    return span;
+  }
+  return modifedSpan;
+}
+
+/**
+ * Safely set attributes on a span JSON.
+ * If an attribute already exists, it will not be overwritten.
+ */
+function safeSetSpanJSONAttributes(
+  spanJSON,
+  newAttributes,
+) {
+  const originalAttributes = spanJSON.attributes ?? (spanJSON.attributes = {});
+
+  Object.entries(newAttributes).forEach(([key, value]) => {
+    if (value != null && !(key in originalAttributes)) {
+      originalAttributes[key] = value;
+    }
+  });
+}
+
+export { applyBeforeSendSpanCallback, captureSpan, safeSetSpanJSONAttributes };
+//# sourceMappingURL=captureSpan.js.map

package/build/esm/tracing/spans/captureSpan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureSpan.js","sources":["../../../../src/tracing/spans/captureSpan.ts"],"sourcesContent":["import type { RawAttributes } from '../../attributes';\nimport type { Client } from '../../client';\nimport type { ScopeData } from '../../scope';\nimport {\n  SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,\n  SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,\n  SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME,\n  SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,\n  SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID,\n  SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  SEMANTIC_ATTRIBUTE_USER_EMAIL,\n  SEMANTIC_ATTRIBUTE_USER_ID,\n  SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS,\n  SEMANTIC_ATTRIBUTE_USER_USERNAME,\n} from '../../semanticAttributes';\nimport type { SerializedStreamedSpan, Span, StreamedSpanJSON } from '../../types-hoist/span';\nimport { getCombinedScopeData } from '../../utils/scopeData';\nimport {\n  INTERNAL_getSegmentSpan,\n  showSpanDropWarning,\n  spanToStreamedSpanJSON,\n  streamedSpanJsonToSerializedSpan,\n} from '../../utils/spanUtils';\nimport { getCapturedScopesOnSpan } from '../utils';\nimport { isStreamedBeforeSendSpanCallback } from './beforeSendSpan';\n\nexport type SerializedStreamedSpanWithSegmentSpan = SerializedStreamedSpan & {\n  _segmentSpan: Span;\n};\n\n/**\n * Captures a span and returns a JSON representation to be enqueued for sending.\n *\n * IMPORTANT: This function converts the span to JSON immediately to avoid writing\n * to an already-ended OTel span instance (which is blocked by the OTel Span class).\n *\n * @returns the final serialized span with a reference to its segment span. This reference\n * is needed later on to compute the DSC for the span envelope.\n */\nexport function captureSpan(span: Span, client: Client): SerializedStreamedSpanWithSegmentSpan {\n  // Convert to JSON FIRST - we cannot write to an already-ended span\n  const spanJSON = spanToStreamedSpanJSON(span);\n\n  const segmentSpan = INTERNAL_getSegmentSpan(span);\n  const serializedSegmentSpan = spanToStreamedSpanJSON(segmentSpan);\n\n  const { isolationScope: spanIsolationScope, scope: spanScope } = getCapturedScopesOnSpan(span);\n\n  const finalScopeData = getCombinedScopeData(spanIsolationScope, spanScope);\n\n  applyCommonSpanAttributes(spanJSON, serializedSegmentSpan, client, finalScopeData);\n\n  if (spanJSON.is_segment) {\n    applyScopeToSegmentSpan(spanJSON, finalScopeData);\n    // Allow hook subscribers to mutate the segment span JSON\n    client.emit('processSegmentSpan', spanJSON);\n  }\n\n  // Allow hook subscribers to mutate the span JSON\n  client.emit('processSpan', spanJSON);\n\n  const { beforeSendSpan } = client.getOptions();\n  const processedSpan =\n    beforeSendSpan && isStreamedBeforeSendSpanCallback(beforeSendSpan)\n      ? applyBeforeSendSpanCallback(spanJSON, beforeSendSpan)\n      : spanJSON;\n\n  // Backfill sentry.span.source from sentry.source. Only `sentry.span.source` is respected by Sentry.\n  // TODO(v11): Remove this backfill once we renamed SEMANTIC_ATTRIBUTE_SENTRY_SOURCE to sentry.span.source\n  const spanNameSource = processedSpan.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n  if (spanNameSource) {\n    safeSetSpanJSONAttributes(processedSpan, {\n      // Purposefully not using a constant defined here like in other attributes:\n      // This will be the name for SEMANTIC_ATTRIBUTE_SENTRY_SOURCE in v11\n      'sentry.span.source': spanNameSource,\n    });\n  }\n\n  return {\n    ...streamedSpanJsonToSerializedSpan(processedSpan),\n    _segmentSpan: segmentSpan,\n  };\n}\n\nfunction applyScopeToSegmentSpan(_segmentSpanJSON: StreamedSpanJSON, _scopeData: ScopeData): void {\n  // TODO: Apply all scope and request data from auto instrumentation (contexts, request) to segment span\n  // This will follow in a separate PR\n}\n\nfunction applyCommonSpanAttributes(\n  spanJSON: StreamedSpanJSON,\n  serializedSegmentSpan: StreamedSpanJSON,\n  client: Client,\n  scopeData: ScopeData,\n): void {\n  const sdk = client.getSdkMetadata();\n  const { release, environment, sendDefaultPii } = client.getOptions();\n\n  // avoid overwriting any previously set attributes (from users or potentially our SDK instrumentation)\n  safeSetSpanJSONAttributes(spanJSON, {\n    [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: release,\n    [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: environment,\n    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: serializedSegmentSpan.name,\n    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]: serializedSegmentSpan.span_id,\n    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]: sdk?.sdk?.name,\n    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]: sdk?.sdk?.version,\n    ...(sendDefaultPii\n      ? {\n          [SEMANTIC_ATTRIBUTE_USER_ID]: scopeData.user?.id,\n          [SEMANTIC_ATTRIBUTE_USER_EMAIL]: scopeData.user?.email,\n          [SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]: scopeData.user?.ip_address,\n          [SEMANTIC_ATTRIBUTE_USER_USERNAME]: scopeData.user?.username,\n        }\n      : {}),\n    ...scopeData.attributes,\n  });\n}\n\n/**\n * Apply a user-provided beforeSendSpan callback to a span JSON.\n */\nexport function applyBeforeSendSpanCallback(\n  span: StreamedSpanJSON,\n  beforeSendSpan: (span: StreamedSpanJSON) => StreamedSpanJSON,\n): StreamedSpanJSON {\n  const modifedSpan = beforeSendSpan(span);\n  if (!modifedSpan) {\n    showSpanDropWarning();\n    return span;\n  }\n  return modifedSpan;\n}\n\n/**\n * Safely set attributes on a span JSON.\n * If an attribute already exists, it will not be overwritten.\n */\nexport function safeSetSpanJSONAttributes(\n  spanJSON: StreamedSpanJSON,\n  newAttributes: RawAttributes<Record<string, unknown>>,\n): void {\n  const originalAttributes = spanJSON.attributes ?? (spanJSON.attributes = {});\n\n  Object.entries(newAttributes).forEach(([key, value]) => {\n    if (value != null && !(key in originalAttributes)) {\n      originalAttributes[key] = value;\n    }\n  });\n}\n"],"names":[],"mappings":"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"}

package/build/esm/tracing/spans/envelope.js

@@ -0,0 +1,36 @@
+import { dsnToString } from '../../utils/dsn.js';
+import { getSdkMetadataForEnvelopeHeader, createEnvelope } from '../../utils/envelope.js';
+
+/**
+ * Creates a span v2 span streaming envelope
+ */
+function createStreamedSpanEnvelope(
+  serializedSpans,
+  dsc,
+  client,
+) {
+  const dsn = client.getDsn();
+  const tunnel = client.getOptions().tunnel;
+  const sdk = getSdkMetadataForEnvelopeHeader(client.getOptions()._metadata);
+
+  const headers = {
+    sent_at: new Date().toISOString(),
+    ...(dscHasRequiredProps(dsc) && { trace: dsc }),
+    ...(sdk && { sdk }),
+    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),
+  };
+
+  const spanContainer = [
+    { type: 'span', item_count: serializedSpans.length, content_type: 'application/vnd.sentry.items.span.v2+json' },
+    { items: serializedSpans },
+  ];
+
+  return createEnvelope(headers, [spanContainer]);
+}
+
+function dscHasRequiredProps(dsc) {
+  return !!dsc.trace_id && !!dsc.public_key;
+}
+
+export { createStreamedSpanEnvelope };
+//# sourceMappingURL=envelope.js.map

package/build/esm/tracing/spans/envelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.js","sources":["../../../../src/tracing/spans/envelope.ts"],"sourcesContent":["import type { Client } from '../../client';\nimport type { DynamicSamplingContext, SpanContainerItem, StreamedSpanEnvelope } from '../../types-hoist/envelope';\nimport type { SerializedStreamedSpan } from '../../types-hoist/span';\nimport { dsnToString } from '../../utils/dsn';\nimport { createEnvelope, getSdkMetadataForEnvelopeHeader } from '../../utils/envelope';\n\n/**\n * Creates a span v2 span streaming envelope\n */\nexport function createStreamedSpanEnvelope(\n  serializedSpans: Array<SerializedStreamedSpan>,\n  dsc: Partial<DynamicSamplingContext>,\n  client: Client,\n): StreamedSpanEnvelope {\n  const dsn = client.getDsn();\n  const tunnel = client.getOptions().tunnel;\n  const sdk = getSdkMetadataForEnvelopeHeader(client.getOptions()._metadata);\n\n  const headers: StreamedSpanEnvelope[0] = {\n    sent_at: new Date().toISOString(),\n    ...(dscHasRequiredProps(dsc) && { trace: dsc }),\n    ...(sdk && { sdk }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n  };\n\n  const spanContainer: SpanContainerItem = [\n    { type: 'span', item_count: serializedSpans.length, content_type: 'application/vnd.sentry.items.span.v2+json' },\n    { items: serializedSpans },\n  ];\n\n  return createEnvelope<StreamedSpanEnvelope>(headers, [spanContainer]);\n}\n\nfunction dscHasRequiredProps(dsc: Partial<DynamicSamplingContext>): dsc is DynamicSamplingContext {\n  return !!dsc.trace_id && !!dsc.public_key;\n}\n"],"names":[],"mappings":";;;AAMA;AACA;AACA;AACO,SAAS,0BAA0B;AAC1C,EAAE,eAAe;AACjB,EAAE,GAAG;AACL,EAAE,MAAM;AACR,EAAwB;AACxB,EAAE,MAAM,GAAA,GAAM,MAAM,CAAC,MAAM,EAAE;AAC7B,EAAE,MAAM,SAAS,MAAM,CAAC,UAAU,EAAE,CAAC,MAAM;AAC3C,EAAE,MAAM,GAAA,GAAM,+BAA+B,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,SAAS,CAAC;;AAE5E,EAAE,MAAM,OAAO,GAA4B;AAC3C,IAAI,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;AACrC,IAAI,IAAI,mBAAmB,CAAC,GAAG,CAAA,IAAK,EAAE,KAAK,EAAE,GAAA,EAAK,CAAC;AACnD,IAAI,IAAI,GAAA,IAAO,EAAE,GAAA,EAAK,CAAC;AACvB,IAAI,IAAI,CAAC,CAAC,MAAA,IAAU,GAAA,IAAO,EAAE,GAAG,EAAE,WAAW,CAAC,GAAG,CAAA,EAAG,CAAC;AACrD,GAAG;;AAEH,EAAE,MAAM,aAAa,GAAsB;AAC3C,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,6CAA6C;AACnH,IAAI,EAAE,KAAK,EAAE,eAAA,EAAiB;AAC9B,GAAG;;AAEH,EAAE,OAAO,cAAc,CAAuB,OAAO,EAAE,CAAC,aAAa,CAAC,CAAC;AACvE;;AAEA,SAAS,mBAAmB,CAAC,GAAG,EAAkE;AAClG,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,QAAA,IAAY,CAAC,CAAC,GAAG,CAAC,UAAU;AAC3C;;;;"}

package/build/esm/tracing/spans/estimateSize.js

@@ -0,0 +1,39 @@
+import { estimateTypedAttributesSizeInBytes } from '../../attributes.js';
+
+/**
+ * Estimates the serialized byte size of a {@link SerializedStreamedSpan}.
+ *
+ * Uses 2 bytes per character as a UTF-16 approximation, and 8 bytes per number.
+ * The estimate is intentionally conservative and may be slightly lower than the
+ * actual byte size on the wire.
+ * We compensate for this by setting the span buffers internal limit well below the limit
+ * of how large an actual span v2 envelope may be.
+ */
+function estimateSerializedSpanSizeInBytes(span) {
+  /*
+   * Fixed-size fields are pre-computed as a constant for performance:
+   * - two timestamps (8 bytes each = 16)
+   * - is_segment boolean (5 bytes, assumed false for most spans)
+   * - trace_id  – always 32 hex chars (64 bytes)
+   * - span_id   – always 16 hex chars (32 bytes)
+   * - parent_span_id – 16 hex chars, assumed present for most spans (32 bytes)
+   * - status "ok" – most common value (8 bytes)
+   * = 156 bytes total base
+   */
+  let weight = 156;
+  weight += span.name.length * 2;
+  weight += estimateTypedAttributesSizeInBytes(span.attributes);
+  if (span.links && span.links.length > 0) {
+    // Assumption: Links are roughly equal in number of attributes
+    // probably not always true but allows us to cut down on runtime
+    const firstLink = span.links[0];
+    const attributes = firstLink?.attributes;
+    // Fixed size 100 due to span_id, trace_id and sampled flag (see above)
+    const linkWeight = 100 + (attributes ? estimateTypedAttributesSizeInBytes(attributes) : 0);
+    weight += linkWeight * span.links.length;
+  }
+  return weight;
+}
+
+export { estimateSerializedSpanSizeInBytes };
+//# sourceMappingURL=estimateSize.js.map

package/build/esm/tracing/spans/estimateSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimateSize.js","sources":["../../../../src/tracing/spans/estimateSize.ts"],"sourcesContent":["import { estimateTypedAttributesSizeInBytes } from '../../attributes';\nimport type { SerializedStreamedSpan } from '../../types-hoist/span';\n\n/**\n * Estimates the serialized byte size of a {@link SerializedStreamedSpan}.\n *\n * Uses 2 bytes per character as a UTF-16 approximation, and 8 bytes per number.\n * The estimate is intentionally conservative and may be slightly lower than the\n * actual byte size on the wire.\n * We compensate for this by setting the span buffers internal limit well below the limit\n * of how large an actual span v2 envelope may be.\n */\nexport function estimateSerializedSpanSizeInBytes(span: SerializedStreamedSpan): number {\n  /*\n   * Fixed-size fields are pre-computed as a constant for performance:\n   * - two timestamps (8 bytes each = 16)\n   * - is_segment boolean (5 bytes, assumed false for most spans)\n   * - trace_id  – always 32 hex chars (64 bytes)\n   * - span_id   – always 16 hex chars (32 bytes)\n   * - parent_span_id – 16 hex chars, assumed present for most spans (32 bytes)\n   * - status \"ok\" – most common value (8 bytes)\n   * = 156 bytes total base\n   */\n  let weight = 156;\n  weight += span.name.length * 2;\n  weight += estimateTypedAttributesSizeInBytes(span.attributes);\n  if (span.links && span.links.length > 0) {\n    // Assumption: Links are roughly equal in number of attributes\n    // probably not always true but allows us to cut down on runtime\n    const firstLink = span.links[0];\n    const attributes = firstLink?.attributes;\n    // Fixed size 100 due to span_id, trace_id and sampled flag (see above)\n    const linkWeight = 100 + (attributes ? estimateTypedAttributesSizeInBytes(attributes) : 0);\n    weight += linkWeight * span.links.length;\n  }\n  return weight;\n}\n"],"names":[],"mappings":";;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,iCAAiC,CAAC,IAAI,EAAkC;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,IAAI,MAAA,GAAS,GAAG;AAClB,EAAE,MAAA,IAAU,IAAI,CAAC,IAAI,CAAC,MAAA,GAAS,CAAC;AAChC,EAAE,UAAU,kCAAkC,CAAC,IAAI,CAAC,UAAU,CAAC;AAC/D,EAAE,IAAI,IAAI,CAAC,KAAA,IAAS,IAAI,CAAC,KAAK,CAAC,MAAA,GAAS,CAAC,EAAE;AAC3C;AACA;AACA,IAAI,MAAM,YAAY,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACnC,IAAI,MAAM,UAAA,GAAa,SAAS,EAAE,UAAU;AAC5C;AACA,IAAI,MAAM,UAAA,GAAa,GAAA,IAAO,UAAA,GAAa,kCAAkC,CAAC,UAAU,CAAA,GAAI,CAAC,CAAC;AAC9F,IAAI,MAAA,IAAU,UAAA,GAAa,IAAI,CAAC,KAAK,CAAC,MAAM;AAC5C,EAAE;AACF,EAAE,OAAO,MAAM;AACf;;;;"}

package/build/esm/tracing/spans/hasSpanStreamingEnabled.js

@@ -0,0 +1,9 @@
+/**
+ * Determines if span streaming is enabled for the given client
+ */
+function hasSpanStreamingEnabled(client) {
+  return client.getOptions().traceLifecycle === 'stream';
+}
+
+export { hasSpanStreamingEnabled };
+//# sourceMappingURL=hasSpanStreamingEnabled.js.map

package/build/esm/tracing/spans/hasSpanStreamingEnabled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasSpanStreamingEnabled.js","sources":["../../../../src/tracing/spans/hasSpanStreamingEnabled.ts"],"sourcesContent":["import type { Client } from '../../client';\n\n/**\n * Determines if span streaming is enabled for the given client\n */\nexport function hasSpanStreamingEnabled(client: Client): boolean {\n  return client.getOptions().traceLifecycle === 'stream';\n}\n"],"names":[],"mappings":"AAEA;AACA;AACA;AACO,SAAS,uBAAuB,CAAC,MAAM,EAAmB;AACjE,EAAE,OAAO,MAAM,CAAC,UAAU,EAAE,CAAC,cAAA,KAAmB,QAAQ;AACxD;;;;"}

package/build/esm/tracing/spans/spanBuffer.js

@@ -0,0 +1,156 @@
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { debug } from '../../utils/debug-logger.js';
+import { safeUnref } from '../../utils/timer.js';
+import { getDynamicSamplingContextFromSpan } from '../dynamicSamplingContext.js';
+import { createStreamedSpanEnvelope } from './envelope.js';
+import { estimateSerializedSpanSizeInBytes } from './estimateSize.js';
+
+/**
+ * We must not send more than 1000 spans in one envelope.
+ * Otherwise the envelope is dropped by Relay.
+ */
+const MAX_SPANS_PER_ENVELOPE = 1000;
+
+const MAX_TRACE_WEIGHT_IN_BYTES = 5000000;
+
+/**
+ * A buffer for serialized streamed span JSON objects that flushes them to Sentry in Span v2 envelopes.
+ * Handles per-trace timeout-based flushing, size thresholds, and graceful shutdown.
+ * Also handles computation of the Dynamic Sampling Context (DSC) for the trace, if it wasn't yet
+ * frozen onto the segment span.
+ *
+ * For this, we need the reference to the segment span instance, from
+ * which we compute the DSC. Doing this in the buffer ensures that we compute the DSC as late as possible,
+ * allowing span name and data updates up to this point. Worth noting here that the segment span is likely
+ * still active and modifyable when child spans are added to the buffer.
+ */
+class SpanBuffer {
+  /* Bucket spans by their trace id, along with accumulated size and a per-trace flush timeout */
+
+   constructor(client, options) {
+    this._traceBuckets = new Map();
+    this._client = client;
+
+    const { maxSpanLimit, flushInterval, maxTraceWeightInBytes } = options ?? {};
+
+    this._maxSpanLimit =
+      maxSpanLimit && maxSpanLimit > 0 && maxSpanLimit <= MAX_SPANS_PER_ENVELOPE
+        ? maxSpanLimit
+        : MAX_SPANS_PER_ENVELOPE;
+    this._flushInterval = flushInterval && flushInterval > 0 ? flushInterval : 5000;
+    this._maxTraceWeight =
+      maxTraceWeightInBytes && maxTraceWeightInBytes > 0 ? maxTraceWeightInBytes : MAX_TRACE_WEIGHT_IN_BYTES;
+
+    this._client.on('flush', () => {
+      this.drain();
+    });
+
+    this._client.on('close', () => {
+      // No need to drain the buffer here as `Client.close()` internally already calls `Client.flush()`
+      // which already invokes the `flush` hook and thus drains the buffer.
+      this._traceBuckets.forEach(bucket => {
+        clearTimeout(bucket.timeout);
+      });
+      this._traceBuckets.clear();
+    });
+  }
+
+  /**
+   * Add a span to the buffer.
+   */
+   add(spanJSON) {
+    const traceId = spanJSON.trace_id;
+    let bucket = this._traceBuckets.get(traceId);
+
+    if (!bucket) {
+      bucket = {
+        spans: new Set(),
+        size: 0,
+        timeout: safeUnref(
+          setTimeout(() => {
+            this.flush(traceId);
+          }, this._flushInterval),
+        ),
+      };
+      this._traceBuckets.set(traceId, bucket);
+    }
+
+    bucket.spans.add(spanJSON);
+    bucket.size += estimateSerializedSpanSizeInBytes(spanJSON);
+
+    if (bucket.spans.size >= this._maxSpanLimit || bucket.size >= this._maxTraceWeight) {
+      this.flush(traceId);
+    }
+  }
+
+  /**
+   * Drain and flush all buffered traces.
+   */
+   drain() {
+    if (!this._traceBuckets.size) {
+      return;
+    }
+
+    DEBUG_BUILD && debug.log(`Flushing span tree map with ${this._traceBuckets.size} traces`);
+
+    this._traceBuckets.forEach((_, traceId) => {
+      this.flush(traceId);
+    });
+  }
+
+  /**
+   * Flush spans of a specific trace.
+   * In contrast to {@link SpanBuffer.drain}, this method does not flush all traces, but only the one with the given traceId.
+   */
+   flush(traceId) {
+    const bucket = this._traceBuckets.get(traceId);
+    if (!bucket) {
+      return;
+    }
+
+    if (!bucket.spans.size) {
+      // we should never get here, given we always add a span when we create a new bucket
+      // and delete the bucket once we flush out the trace
+      this._removeTrace(traceId);
+      return;
+    }
+
+    const spans = Array.from(bucket.spans);
+
+    const segmentSpan = spans[0]?._segmentSpan;
+    if (!segmentSpan) {
+      DEBUG_BUILD && debug.warn('No segment span reference found on span JSON, cannot compute DSC');
+      this._removeTrace(traceId);
+      return;
+    }
+
+    const dsc = getDynamicSamplingContextFromSpan(segmentSpan);
+
+    const cleanedSpans = spans.map(spanJSON => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { _segmentSpan, ...cleanSpanJSON } = spanJSON;
+      return cleanSpanJSON;
+    });
+
+    const envelope = createStreamedSpanEnvelope(cleanedSpans, dsc, this._client);
+
+    DEBUG_BUILD && debug.log(`Sending span envelope for trace ${traceId} with ${cleanedSpans.length} spans`);
+
+    this._client.sendEnvelope(envelope).then(null, reason => {
+      DEBUG_BUILD && debug.error('Error while sending streamed span envelope:', reason);
+    });
+
+    this._removeTrace(traceId);
+  }
+
+   _removeTrace(traceId) {
+    const bucket = this._traceBuckets.get(traceId);
+    if (bucket) {
+      clearTimeout(bucket.timeout);
+    }
+    this._traceBuckets.delete(traceId);
+  }
+}
+
+export { SpanBuffer };
+//# sourceMappingURL=spanBuffer.js.map

package/build/esm/tracing/spans/spanBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanBuffer.js","sources":["../../../../src/tracing/spans/spanBuffer.ts"],"sourcesContent":["import type { Client } from '../../client';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport type { SerializedStreamedSpan } from '../../types-hoist/span';\nimport { debug } from '../../utils/debug-logger';\nimport { safeUnref } from '../../utils/timer';\nimport { getDynamicSamplingContextFromSpan } from '../dynamicSamplingContext';\nimport type { SerializedStreamedSpanWithSegmentSpan } from './captureSpan';\nimport { createStreamedSpanEnvelope } from './envelope';\nimport { estimateSerializedSpanSizeInBytes } from './estimateSize';\n\n/**\n * We must not send more than 1000 spans in one envelope.\n * Otherwise the envelope is dropped by Relay.\n */\nconst MAX_SPANS_PER_ENVELOPE = 1000;\n\nconst MAX_TRACE_WEIGHT_IN_BYTES = 5_000_000;\n\ninterface TraceBucket {\n  spans: Set<SerializedStreamedSpanWithSegmentSpan>;\n  size: number;\n  timeout: ReturnType<typeof setTimeout>;\n}\n\nexport interface SpanBufferOptions {\n  /**\n   * Max spans per trace before auto-flush\n   * Must not exceed 1000.\n   *\n   * @default 1_000\n   */\n  maxSpanLimit?: number;\n\n  /**\n   * Per-trace flush timeout in ms. A timeout is started when a trace bucket is first created\n   * and fires flush() for that specific trace when it expires.\n   * Must be greater than 0.\n   *\n   * @default 5_000\n   */\n  flushInterval?: number;\n\n  /**\n   * Max accumulated byte weight of spans per trace before auto-flush.\n   * Size is estimated, not exact. Uses 2 bytes per character for strings (UTF-16).\n   *\n   * @default 5_000_000 (5 MB)\n   */\n  maxTraceWeightInBytes?: number;\n}\n\n/**\n * A buffer for serialized streamed span JSON objects that flushes them to Sentry in Span v2 envelopes.\n * Handles per-trace timeout-based flushing, size thresholds, and graceful shutdown.\n * Also handles computation of the Dynamic Sampling Context (DSC) for the trace, if it wasn't yet\n * frozen onto the segment span.\n *\n * For this, we need the reference to the segment span instance, from\n * which we compute the DSC. Doing this in the buffer ensures that we compute the DSC as late as possible,\n * allowing span name and data updates up to this point. Worth noting here that the segment span is likely\n * still active and modifyable when child spans are added to the buffer.\n */\nexport class SpanBuffer {\n  /* Bucket spans by their trace id, along with accumulated size and a per-trace flush timeout */\n  private _traceBuckets: Map<string, TraceBucket>;\n\n  private _client: Client;\n  private _maxSpanLimit: number;\n  private _flushInterval: number;\n  private _maxTraceWeight: number;\n\n  public constructor(client: Client, options?: SpanBufferOptions) {\n    this._traceBuckets = new Map();\n    this._client = client;\n\n    const { maxSpanLimit, flushInterval, maxTraceWeightInBytes } = options ?? {};\n\n    this._maxSpanLimit =\n      maxSpanLimit && maxSpanLimit > 0 && maxSpanLimit <= MAX_SPANS_PER_ENVELOPE\n        ? maxSpanLimit\n        : MAX_SPANS_PER_ENVELOPE;\n    this._flushInterval = flushInterval && flushInterval > 0 ? flushInterval : 5_000;\n    this._maxTraceWeight =\n      maxTraceWeightInBytes && maxTraceWeightInBytes > 0 ? maxTraceWeightInBytes : MAX_TRACE_WEIGHT_IN_BYTES;\n\n    this._client.on('flush', () => {\n      this.drain();\n    });\n\n    this._client.on('close', () => {\n      // No need to drain the buffer here as `Client.close()` internally already calls `Client.flush()`\n      // which already invokes the `flush` hook and thus drains the buffer.\n      this._traceBuckets.forEach(bucket => {\n        clearTimeout(bucket.timeout);\n      });\n      this._traceBuckets.clear();\n    });\n  }\n\n  /**\n   * Add a span to the buffer.\n   */\n  public add(spanJSON: SerializedStreamedSpanWithSegmentSpan): void {\n    const traceId = spanJSON.trace_id;\n    let bucket = this._traceBuckets.get(traceId);\n\n    if (!bucket) {\n      bucket = {\n        spans: new Set(),\n        size: 0,\n        timeout: safeUnref(\n          setTimeout(() => {\n            this.flush(traceId);\n          }, this._flushInterval),\n        ),\n      };\n      this._traceBuckets.set(traceId, bucket);\n    }\n\n    bucket.spans.add(spanJSON);\n    bucket.size += estimateSerializedSpanSizeInBytes(spanJSON);\n\n    if (bucket.spans.size >= this._maxSpanLimit || bucket.size >= this._maxTraceWeight) {\n      this.flush(traceId);\n    }\n  }\n\n  /**\n   * Drain and flush all buffered traces.\n   */\n  public drain(): void {\n    if (!this._traceBuckets.size) {\n      return;\n    }\n\n    DEBUG_BUILD && debug.log(`Flushing span tree map with ${this._traceBuckets.size} traces`);\n\n    this._traceBuckets.forEach((_, traceId) => {\n      this.flush(traceId);\n    });\n  }\n\n  /**\n   * Flush spans of a specific trace.\n   * In contrast to {@link SpanBuffer.drain}, this method does not flush all traces, but only the one with the given traceId.\n   */\n  public flush(traceId: string): void {\n    const bucket = this._traceBuckets.get(traceId);\n    if (!bucket) {\n      return;\n    }\n\n    if (!bucket.spans.size) {\n      // we should never get here, given we always add a span when we create a new bucket\n      // and delete the bucket once we flush out the trace\n      this._removeTrace(traceId);\n      return;\n    }\n\n    const spans = Array.from(bucket.spans);\n\n    const segmentSpan = spans[0]?._segmentSpan;\n    if (!segmentSpan) {\n      DEBUG_BUILD && debug.warn('No segment span reference found on span JSON, cannot compute DSC');\n      this._removeTrace(traceId);\n      return;\n    }\n\n    const dsc = getDynamicSamplingContextFromSpan(segmentSpan);\n\n    const cleanedSpans: SerializedStreamedSpan[] = spans.map(spanJSON => {\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      const { _segmentSpan, ...cleanSpanJSON } = spanJSON;\n      return cleanSpanJSON;\n    });\n\n    const envelope = createStreamedSpanEnvelope(cleanedSpans, dsc, this._client);\n\n    DEBUG_BUILD && debug.log(`Sending span envelope for trace ${traceId} with ${cleanedSpans.length} spans`);\n\n    this._client.sendEnvelope(envelope).then(null, reason => {\n      DEBUG_BUILD && debug.error('Error while sending streamed span envelope:', reason);\n    });\n\n    this._removeTrace(traceId);\n  }\n\n  private _removeTrace(traceId: string): void {\n    const bucket = this._traceBuckets.get(traceId);\n    if (bucket) {\n      clearTimeout(bucket.timeout);\n    }\n    this._traceBuckets.delete(traceId);\n  }\n}\n"],"names":[],"mappings":"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"}

package/build/esm/tracing/trace.js

@@ -2,11 +2,13 @@ import { getAsyncContextStrategy } from '../asyncContext/index.js';
 import { getMainCarrier } from '../carrier.js';
 import { getClient, withScope, getCurrentScope, getIsolationScope } from '../currentScopes.js';
 import { DEBUG_BUILD } from '../debug-build.js';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes.js';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes.js';
 import { baggageHeaderToDynamicSamplingContext } from '../utils/baggage.js';
 import { debug } from '../utils/debug-logger.js';
 import { handleCallbackErrors } from '../utils/handleCallbackErrors.js';
 import { hasSpansEnabled } from '../utils/hasSpansEnabled.js';
+import { shouldIgnoreSpan } from '../utils/should-ignore-span.js';
+import { hasSpanStreamingEnabled } from './spans/hasSpanStreamingEnabled.js';
 import { parseSampleRate } from '../utils/parseSampleRate.js';
 import { generateTraceId } from '../utils/propagationContext.js';
 import { safeMathRandom } from '../utils/randomSafeContext.js';
@@ -67,7 +69,12 @@ function startSpan(options, callback) {
             scope,
           });
 
-      _setSpanForScope(scope, activeSpan);
+      // Ignored root spans still need to be set on scope so that `getActiveSpan()` returns them
+      // and descendants are also non-recording. Ignored child spans don't need this because
+      // the parent span is already on scope.
+      if (!_isIgnoredSpan(activeSpan) || !parentSpan) {
+        _setSpanForScope(scope, activeSpan);
+      }
 
       return handleCallbackErrors(
         () => callback(activeSpan),
@@ -125,7 +132,11 @@ function startSpanManual(options, callback) {
             scope,
           });
 
-      _setSpanForScope(scope, activeSpan);
+      // We don't set ignored child spans onto the scope because there likely is an active,
+      // unignored span on the scope already.
+      if (!_isIgnoredSpan(activeSpan) || !parentSpan) {
+        _setSpanForScope(scope, activeSpan);
+      }
 
       return handleCallbackErrors(
         // We pass the `finish` function to the callback, so the user can finish the span manually
@@ -326,6 +337,20 @@ function createChildOrRootSpan({
     return span;
   }
 
+  const client = getClient();
+  if (_shouldIgnoreStreamedSpan(client, spanArguments)) {
+    if (!_isTracingSuppressed(scope)) {
+      // if tracing is actively suppressed (Sentry.suppressTracing(...)),
+      // we don't want to record a client outcome for the ignored span
+      client?.recordDroppedEvent('ignored', 'span');
+    }
+
+    return new SentryNonRecordingSpan({
+      dropReason: 'ignored',
+      traceId: parentSpan?.spanContext().traceId ?? scope.getPropagationContext().traceId,
+    });
+  }
+
   const isolationScope = getIsolationScope();
 
   let span;
@@ -425,9 +450,9 @@ function _startRootSpan(spanArguments, scope, parentSampled) {
   const finalAttributes = mutableSpanSamplingData.spanAttributes;
 
   const currentPropagationContext = scope.getPropagationContext();
-  const [sampled, sampleRate, localSampleRateWasApplied] = scope.getScopeData().sdkProcessingMetadata[
-    SUPPRESS_TRACING_KEY
-  ]
+  const isTracingSuppressed = _isTracingSuppressed(scope);
+
+  const [sampled, sampleRate, localSampleRateWasApplied] = isTracingSuppressed
     ? [false]
     : sampleSpan(
         options,
@@ -451,9 +476,9 @@ function _startRootSpan(spanArguments, scope, parentSampled) {
     sampled,
   });
 
-  if (!sampled && client) {
+  if (!sampled && client && !isTracingSuppressed) {
     DEBUG_BUILD && debug.log('[Tracing] Discarding root span because its trace was not chosen to be sampled.');
-    client.recordDroppedEvent('sample_rate', 'transaction');
+    client.recordDroppedEvent('sample_rate', hasSpanStreamingEnabled(client) ? 'span' : 'transaction');
   }
 
   if (client) {
@@ -469,7 +494,8 @@ function _startRootSpan(spanArguments, scope, parentSampled) {
  */
 function _startChildSpan(parentSpan, scope, spanArguments) {
   const { spanId, traceId } = parentSpan.spanContext();
-  const sampled = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] ? false : spanIsSampled(parentSpan);
+  const isTracingSuppressed = _isTracingSuppressed(scope);
+  const sampled = isTracingSuppressed ? false : spanIsSampled(parentSpan);
 
   const childSpan = sampled
     ? new SentrySpan({
@@ -483,14 +509,33 @@ function _startChildSpan(parentSpan, scope, spanArguments) {
   addChildSpanToSpan(parentSpan, childSpan);
 
   const client = getClient();
-  if (client) {
-    client.emit('spanStart', childSpan);
-    // If it has an endTimestamp, it's already ended
-    if (spanArguments.endTimestamp) {
-      client.emit('spanEnd', childSpan);
+
+  if (!client) {
+    return childSpan;
+  }
+
+  if (hasSpanStreamingEnabled(client) && childSpan instanceof SentryNonRecordingSpan) {
+    if (parentSpan instanceof SentryNonRecordingSpan && parentSpan.dropReason) {
+      // We land here if the parent span was a segment span that was ignored (`ignoreSpans`).
+      // In this case, the child was also ignored (see `sampled` above) but we need to
+      // record a client outcome for the child.
+      childSpan.dropReason = parentSpan.dropReason;
+      client.recordDroppedEvent(parentSpan.dropReason, 'span');
+    } else if (!isTracingSuppressed) {
+      // Otherwise, the child is not sampled due to sampling of the parent span,
+      // hence we record a sample_rate client outcome for the child.
+      childSpan.dropReason = 'sample_rate';
+      client.recordDroppedEvent('sample_rate', 'span');
     }
   }
 
+  client.emit('spanStart', childSpan);
+  // If it has an endTimestamp, it's already ended
+  if (spanArguments.endTimestamp) {
+    client.emit('spanEnd', childSpan);
+    client.emit('afterSpanEnd', childSpan);
+  }
+
   return childSpan;
 }
 
@@ -528,5 +573,30 @@ function getActiveSpanWrapper(parentSpan) {
     : (callback) => callback();
 }
 
+/* Checks if `ignoreSpans` applies (extracted for bundle size)*/
+function _shouldIgnoreStreamedSpan(client, spanArguments) {
+  const ignoreSpans = client?.getOptions().ignoreSpans;
+
+  if (!client || !hasSpanStreamingEnabled(client) || !ignoreSpans?.length) {
+    return false;
+  }
+
+  return shouldIgnoreSpan(
+    {
+      description: spanArguments.name || '',
+      op: spanArguments.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] || spanArguments.op,
+    },
+    ignoreSpans,
+  );
+}
+
+function _isIgnoredSpan(span) {
+  return span instanceof SentryNonRecordingSpan && span.dropReason === 'ignored';
+}
+
+function _isTracingSuppressed(scope) {
+  return scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] === true;
+}
+
 export { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual, suppressTracing, withActiveSpan };
 //# sourceMappingURL=trace.js.map