feat: Delete store endpoint code

packages/core/src/api.ts

@@ -35,8 +35,8 @@ function getBaseApiEndpoint(dsn: DsnComponents): string {
 }
 
 /** Returns the ingest API endpoint for target. */
-function _getIngestEndpoint(dsn: DsnComponents, target: 'store' | 'envelope'): string {
-  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/${target}/`;
+function _getIngestEndpoint(dsn: DsnComponents): string {
+  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;
 }
 
 /** Returns a URL-encoded string with auth config suitable for a query string. */
@@ -49,54 +49,13 @@ function _encodedAuth(dsn: DsnComponents): string {
   });
 }
 
-/** Returns the store endpoint URL. */
-export function getStoreEndpoint(dsn: DsnComponents): string {
-  return _getIngestEndpoint(dsn, 'store');
-}
-
-/**
- * Returns the store endpoint URL with auth in the query string.
- *
- * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
- */
-export function getStoreEndpointWithUrlEncodedAuth(dsn: DsnComponents): string {
-  return `${getStoreEndpoint(dsn)}?${_encodedAuth(dsn)}`;
-}
-
-/** Returns the envelope endpoint URL. */
-function _getEnvelopeEndpoint(dsn: DsnComponents): string {
-  return _getIngestEndpoint(dsn, 'envelope');
-}
-
 /**
  * Returns the envelope endpoint URL with auth in the query string.
  *
  * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
  */
 export function getEnvelopeEndpointWithUrlEncodedAuth(dsn: DsnComponents, tunnel?: string): string {
-  return tunnel ? tunnel : `${_getEnvelopeEndpoint(dsn)}?${_encodedAuth(dsn)}`;
-}
-
-/**
- * Returns an object that can be used in request headers.
- * This is needed for node and the old /store endpoint in sentry
- */
-export function getRequestHeaders(
-  dsn: DsnComponents,
-  clientName: string,
-  clientVersion: string,
-): { [key: string]: string } {
-  // CHANGE THIS to use metadata but keep clientName and clientVersion compatible
-  const header = [`Sentry sentry_version=${SENTRY_API_VERSION}`];
-  header.push(`sentry_client=${clientName}/${clientVersion}`);
-  header.push(`sentry_key=${dsn.publicKey}`);
-  if (dsn.pass) {
-    header.push(`sentry_secret=${dsn.pass}`);
-  }
-  return {
-    'Content-Type': 'application/json',
-    'X-Sentry-Auth': header.join(', '),
-  };
+  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn)}`;
 }
 
 /** Returns the url to the report dialog endpoint. */

packages/core/src/baseclient.ts

@@ -32,9 +32,9 @@ import {
 } from '@sentry/utils';
 
 import { getEnvelopeEndpointWithUrlEncodedAuth } from './api';
+import { createEventEnvelope, createSessionEnvelope } from './envelope';
 import { IS_DEBUG_BUILD } from './flags';
 import { IntegrationIndex, setupIntegrations } from './integration';
-import { createEventEnvelope, createSessionEnvelope } from './request';
 
 const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
 
@@ -275,7 +275,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
    */
   public sendSession(session: Session | SessionAggregates): void {
     if (this._dsn) {
-      const [env] = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
+      const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
       this.sendEnvelope(env);
     }
   }

packages/core/src/envelope.ts

@@ -0,0 +1,123 @@
+import {
+  DsnComponents,
+  Event,
+  EventEnvelope,
+  EventItem,
+  SdkInfo,
+  SdkMetadata,
+  SentryRequestType,
+  Session,
+  SessionAggregates,
+  SessionEnvelope,
+  SessionItem,
+} from '@sentry/types';
+import { createEnvelope, dsnToString } from '@sentry/utils';
+
+/** Extract sdk info from from the API metadata */
+function getSdkMetadataForEnvelopeHeader(metadata?: SdkMetadata): SdkInfo | undefined {
+  if (!metadata || !metadata.sdk) {
+    return;
+  }
+  const { name, version } = metadata.sdk;
+  return { name, version };
+}
+
+/**
+ * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.
+ * Merge with existing data if any.
+ **/
+function enhanceEventWithSdkInfo(event: Event, sdkInfo?: SdkInfo): Event {
+  if (!sdkInfo) {
+    return event;
+  }
+  event.sdk = event.sdk || {};
+  event.sdk.name = event.sdk.name || sdkInfo.name;
+  event.sdk.version = event.sdk.version || sdkInfo.version;
+  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];
+  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];
+  return event;
+}
+
+/** Creates an envelope from a Session */
+export function createSessionEnvelope(
+  session: Session | SessionAggregates,
+  dsn: DsnComponents,
+  metadata?: SdkMetadata,
+  tunnel?: string,
+): SessionEnvelope {
+  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
+  const envelopeHeaders = {
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && { dsn: dsnToString(dsn) }),
+  };
+
+  // I know this is hacky but we don't want to add `sessions` to request type since it's never rate limited
+  const type = 'aggregates' in session ? ('sessions' as SentryRequestType) : 'session';
+
+  // TODO (v7) Have to cast type because envelope items do not accept a `SentryRequestType`
+  const envelopeItem = [{ type } as { type: 'session' | 'sessions' }, session] as SessionItem;
+  const envelope = createEnvelope<SessionEnvelope>(envelopeHeaders, [envelopeItem]);
+
+  return envelope;
+}
+
+/**
+ * Create an Envelope from an event.
+ */
+export function createEventEnvelope(
+  event: Event,
+  dsn: DsnComponents,
+  metadata?: SdkMetadata,
+  tunnel?: string,
+): EventEnvelope {
+  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
+  const eventType = event.type || 'event';
+
+  const { transactionSampling } = event.sdkProcessingMetadata || {};
+  const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};
+
+  // TODO: Below is a temporary hack in order to debug a serialization error - see
+  // https://github.com/getsentry/sentry-javascript/issues/2809,
+  // https://github.com/getsentry/sentry-javascript/pull/4425, and
+  // https://github.com/getsentry/sentry-javascript/pull/4574.
+  //
+  // TL; DR: even though we normalize all events (which should prevent this), something is causing `JSON.stringify` to
+  // throw a circular reference error.
+  //
+  // When it's time to remove it:
+  // 1. Delete everything between here and where the request object `req` is created, EXCEPT the line deleting
+  //    `sdkProcessingMetadata`
+  // 2. Restore the original version of the request body, which is commented out
+  // 3. Search for either of the PR URLs above and pull out the companion hacks in the browser playwright tests and the
+  //    baseClient tests in this package
+  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);
+  event.tags = event.tags || {};
+  event.extra = event.extra || {};
+
+  // In theory, all events should be marked as having gone through normalization and so
+  // we should never set this tag/extra data
+  if (!(event.sdkProcessingMetadata && event.sdkProcessingMetadata.baseClientNormalized)) {
+    event.tags.skippedNormalization = true;
+    event.extra.normalizeDepth = event.sdkProcessingMetadata ? event.sdkProcessingMetadata.normalizeDepth : 'unset';
+  }
+
+  // prevent this data from being sent to sentry
+  // TODO: This is NOT part of the hack - DO NOT DELETE
+  delete event.sdkProcessingMetadata;
+
+  const envelopeHeaders = {
+    event_id: event.event_id as string,
+    sent_at: new Date().toISOString(),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && { dsn: dsnToString(dsn) }),
+  };
+  const eventItem: EventItem = [
+    {
+      type: eventType,
+      sample_rates: [{ id: samplingMethod, rate: sampleRate }],
+    },
+    event,
+  ];
+  return createEnvelope<EventEnvelope>(envelopeHeaders, [eventItem]);
+}

packages/core/src/index.ts

@@ -23,15 +23,8 @@ export {
   Scope,
   Session,
 } from '@sentry/hub';
-export {
-  getEnvelopeEndpointWithUrlEncodedAuth,
-  getStoreEndpointWithUrlEncodedAuth,
-  getRequestHeaders,
-  initAPIDetails,
-  getReportDialogEndpoint,
-} from './api';
+export { getEnvelopeEndpointWithUrlEncodedAuth, initAPIDetails, getReportDialogEndpoint } from './api';
 export { BaseClient } from './baseclient';
-export { eventToSentryRequest, sessionToSentryRequest } from './request';
 export { initAndBind } from './sdk';
 export { createTransport } from './transports/base';
 export { SDK_VERSION } from './version';