add measurements to spanJSON

Author: s1gr1d

packages/core/src/envelope.ts

@@ -11,6 +11,7 @@ import type {
   SessionAggregates,
   SessionEnvelope,
   SessionItem,
+  SpanEnvelope,
 } from '@sentry/types';
 import {
   createAttachmentEnvelopeItem,
@@ -19,6 +20,9 @@ import {
   dsnToString,
   getSdkMetadataForEnvelopeHeader,
 } from '@sentry/utils';
+import { createSpanEnvelopeItem } from '@sentry/utils';
+import type { SentrySpan } from './tracing';
+import { spanToJSON } from './utils/spanUtils';
 
 /**
  * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.
@@ -117,3 +121,15 @@ export function createAttachmentEnvelope(
   }
   return createEnvelope<EventEnvelope>(envelopeHeaders, attachmentItems);
 }
+
+/**
+ * Create envelope from Span item.
+ */
+export function createSpanEnvelope(spans: SentrySpan[]): SpanEnvelope {
+  const headers: SpanEnvelope[0] = {
+    sent_at: new Date().toISOString(),
+  };
+
+  const items = spans.map(span => createSpanEnvelopeItem(spanToJSON(span)));
+  return createEnvelope<SpanEnvelope>(headers, items);
+}

packages/core/src/index.ts

@@ -8,7 +8,7 @@ export type { IntegrationIndex } from './integration';
 
 export * from './tracing';
 export * from './semanticAttributes';
-export { createEventEnvelope, createSessionEnvelope, createAttachmentEnvelope } from './envelope';
+export { createEventEnvelope, createSessionEnvelope, createAttachmentEnvelope, createSpanEnvelope } from './envelope';
 export {
   captureCheckIn,
   withMonitor,
@@ -61,7 +61,6 @@ export {
 export { applyScopeDataToEvent, mergeScopeData } from './utils/applyScopeDataToEvent';
 export { prepareEvent } from './utils/prepareEvent';
 export { createCheckInEnvelope } from './checkin';
-export { createSpanEnvelope } from './span';
 export { hasTracingEnabled } from './utils/hasTracingEnabled';
 export { isSentryRequestUrl } from './utils/isSentryRequestUrl';
 export { handleCallbackErrors } from './utils/handleCallbackErrors';

packages/core/src/span.ts

@@ -187,6 +187,7 @@ export class SentrySpan implements Span {
       _metrics_summary: getMetricSummaryJsonForSpan(this),
       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),
     });
   }
 
@@ -297,7 +298,7 @@ export class SentrySpan implements Span {
     };
 
     const measurements = timedEventsToMeasurements(this._events);
-    const hasMeasurements = Object.keys(measurements).length;
+    const hasMeasurements = measurements && Object.keys(measurements).length;
 
     if (hasMeasurements) {
       DEBUG_BUILD &&

packages/core/src/tracing/sentrySpan.ts

@@ -281,6 +281,7 @@ function createAndFinishSpanForOtelSpan(node: SpanNode, spans: SpanJSON[], remai
     op,
     origin,
     _metrics_summary: getMetricSummaryJsonForSpan(span as unknown as Span),
+    measurements: timedEventsToMeasurements(span.events),
   });
 
   spans.push(spanJSON);

packages/opentelemetry/src/spanExporter.ts

@@ -8,7 +8,7 @@ import type { Profile } from './profiling';
 import type { ReplayEvent, ReplayRecordingData } from './replay';
 import type { SdkInfo } from './sdkinfo';
 import type { SerializedSession, Session, SessionAggregates } from './session';
-import type { Span } from './span';
+import type { SpanJSON } from './span';
 
 // Based on: https://develop.sentry.dev/sdk/envelopes/
 
@@ -98,7 +98,7 @@ type ReplayRecordingItem = BaseEnvelopeItem<ReplayRecordingItemHeaders, ReplayRe
 export type StatsdItem = BaseEnvelopeItem<StatsdItemHeaders, string>;
 export type FeedbackItem = BaseEnvelopeItem<FeedbackItemHeaders, FeedbackEvent>;
 export type ProfileItem = BaseEnvelopeItem<ProfileItemHeaders, Profile>;
-export type SpanItem = BaseEnvelopeItem<SpanItemHeaders, Span>;
+export type SpanItem = BaseEnvelopeItem<SpanItemHeaders, Partial<SpanJSON>>;
 
 export type EventEnvelopeHeaders = { event_id: string; sent_at: string; trace?: DynamicSamplingContext };
 type SessionEnvelopeHeaders = { sent_at: string };

packages/types/src/envelope.ts

@@ -1,3 +1,4 @@
+import type { Measurements } from './measurement';
 import type { Primitive } from './misc';
 import type { HrTime } from './opentelemetry';
 import type { SpanStatus } from './spanStatus';
@@ -56,6 +57,7 @@ export interface SpanJSON {
   _metrics_summary?: Record<string, Array<MetricSummary>>;
   profile_id?: string;
   exclusive_time?: number;
+  measurements: Measurements;
 }
 
 // These are aligned with OpenTelemetry trace flags

packages/types/src/span.ts

@@ -11,6 +11,8 @@ import type {
   EventEnvelopeHeaders,
   SdkInfo,
   SdkMetadata,
+  SpanItem,
+  SpanJSON,
 } from '@sentry/types';
 
 import { dsnToString } from './dsn';
@@ -177,6 +179,17 @@ export function parseEnvelope(env: string | Uint8Array): Envelope {
   return [envelopeHeader, items];
 }
 
+/**
+ * Creates envelope item for a single span
+ */
+export function createSpanEnvelopeItem(spanJson: Partial<SpanJSON>): SpanItem {
+  const spanHeaders: SpanItem[0] = {
+    type: 'span',
+  };
+
+  return [spanHeaders, spanJson];
+}
+
 /**
  * Creates attachment envelope items
  */

packages/utils/src/envelope.ts

@@ -1,16 +1,82 @@
-import type { Event, EventEnvelope } from '@sentry/types';
+import type { Event, EventEnvelope, SpanAttributes } from '@sentry/types';
 
+import {
+  SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME,
+  SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT,
+  SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE,
+  spanToJSON,
+} from '@sentry/core';
+import { SentrySpan } from '@sentry/core';
 import {
   addItemToEnvelope,
   createEnvelope,
+  createSpanEnvelopeItem,
   forEachEnvelopeItem,
   parseEnvelope,
   serializeEnvelope,
 } from '../src/envelope';
+import { dropUndefinedKeys } from '../src/object';
 import type { InternalGlobal } from '../src/worldwide';
 import { GLOBAL_OBJ } from '../src/worldwide';
 
 describe('envelope', () => {
+  describe('createSpanEnvelope()', () => {
+    it('span-envelope-item of INP event has the correct object structure', () => {
+      const attributes: SpanAttributes = dropUndefinedKeys({
+        release: 'releaseString',
+        environment: 'dev',
+        transaction: '/test-route',
+        [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: 80,
+        user: 10,
+        profile_id: 'test-profile-id',
+        replay_id: 'test-replay-id',
+      });
+
+      const startTime = 1713365480;
+
+      const span = new SentrySpan({
+        startTimestamp: startTime,
+        endTimestamp: startTime + 2,
+        op: 'ui.interaction.click',
+        name: '<unknown>',
+        attributes,
+      });
+
+      span.addEvent('inp', {
+        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: 'millisecond',
+        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: 100,
+      });
+
+      const spanEnvelopeItem = createSpanEnvelopeItem(spanToJSON(span));
+
+      const expectedObj = {
+        data: {
+          'sentry.origin': expect.any(String),
+          'sentry.op': expect.any(String),
+          release: expect.any(String),
+          environment: expect.any(String),
+          transaction: expect.any(String),
+          'sentry.exclusive_time': expect.any(Number),
+          user: expect.any(Number),
+          profile_id: expect.any(String),
+          replay_id: expect.any(String),
+        },
+        description: expect.any(String),
+        op: expect.any(String),
+        span_id: expect.any(String),
+        start_timestamp: expect.any(Number),
+        timestamp: expect.any(Number),
+        trace_id: expect.any(String),
+        origin: expect.any(String),
+        exclusive_time: expect.any(Number),
+        measurements: { inp: { value: expect.any(Number), unit: expect.any(String) } },
+      };
+
+      expect(spanEnvelopeItem[0].type).toBe('span');
+      expect(spanEnvelopeItem[1]).toMatchObject(expectedObj);
+    });
+  });
+
   describe('createEnvelope()', () => {
     const testTable: Array<[string, Parameters<typeof createEnvelope>[0], Parameters<typeof createEnvelope>[1]]> = [
       ['creates an empty envelope', {}, []],