feat(envelopes): Add SDK metadata to envelope header

packages/angular/package.json

@@ -53,10 +53,32 @@
     "fix": "run-s fix:eslint fix:prettier",
     "fix:prettier": "prettier --write \"{src,test}/**/*.ts\"",
     "fix:eslint": "eslint . --format stylish --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
     "pack": "npm pack"
   },
   "volta": {
     "extends": "../../package.json"
   },
+  "jest": {
+    "collectCoverage": true,
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "testEnvironment": "jsdom",
+    "testMatch": [
+      "**/*.test.ts"
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsConfig": "./tsconfig.json",
+        "diagnostics": false
+      }
+    }
+  },
   "sideEffects": false
 }

packages/angular/src/index.ts

@@ -1,3 +1,6 @@
+import { SDK_VERSION } from '@sentry/browser';
+import { setSDKInfo } from '@sentry/utils';
+
 export * from '@sentry/browser';
 export { createErrorHandler, ErrorHandlerOptions } from './errorhandler';
 export {
@@ -8,3 +11,5 @@ export {
   TraceDirective,
   TraceService,
 } from './tracing';
+
+setSDKInfo('sentry.javascript.angular', 'npm:@sentry/angular', SDK_VERSION);

packages/angular/test/init.test.ts

@@ -0,0 +1,23 @@
+import { getGlobalObject } from '@sentry/utils';
+
+import * as Sentry from '../src/index';
+
+const global = getGlobalObject<Window>();
+
+describe('global SDK metadata', () => {
+  it('sets correct SDK data', () => {
+    // the SDK data is set when we import from (and therefore run) `../src/index.ts` - it sets the angular part itself,
+    // and the browser part gets set when it imports from @sentry/browser - so no action is necessary here before we run
+    // the `expect`s
+
+    expect(global.__SENTRY__?.sdkInfo).toBeDefined();
+    expect(global.__SENTRY__?.sdkInfo?.name).toEqual('sentry.javascript.angular');
+    expect(global.__SENTRY__?.sdkInfo?.version).toEqual(Sentry.SDK_VERSION);
+    expect(global.__SENTRY__?.sdkInfo?.packages).toEqual(
+      expect.arrayContaining([
+        { name: 'npm:@sentry/angular', version: Sentry.SDK_VERSION },
+        { name: 'npm:@sentry/browser', version: Sentry.SDK_VERSION },
+      ]),
+    );
+  });
+});

packages/angular/tsconfig.json

@@ -1,8 +1,9 @@
 {
   "extends": "./tsconfig.build.json",
-  "include": ["src/**/*.ts"],
+  "include": ["src/**/*.ts", "test/**/*.ts"],
   "exclude": ["dist"],
   "compilerOptions": {
-    "rootDir": "."
+    "rootDir": ".",
+    "types": ["jest"]
   }
 }

packages/browser/src/index.ts

@@ -1,10 +1,13 @@
 export * from './exports';
 
 import { Integrations as CoreIntegrations } from '@sentry/core';
-import { getGlobalObject } from '@sentry/utils';
+import { getGlobalObject, setSDKInfo } from '@sentry/utils';
 
 import * as BrowserIntegrations from './integrations';
 import * as Transports from './transports';
+import { SDK_VERSION } from './version';
+
+setSDKInfo('sentry.javascript.browser', 'npm:@sentry/browser', SDK_VERSION, false);
 
 let windowIntegrations = {};
 

packages/browser/test/unit/index.test.ts

@@ -14,6 +14,7 @@ import {
   init,
   Integrations,
   Scope,
+  SDK_VERSION,
   wrap,
 } from '../../src';
 import { SimpleTransport } from './mocks/simpletransport';
@@ -171,6 +172,16 @@ describe('SentryBrowser', () => {
 });
 
 describe('SentryBrowser initialization', () => {
+  it('should set SDK info globally', () => {
+    // the SDK data is set when we import from (and therefore run) `../src/index.ts`, so no action is necessary here
+    // before we run the `expect`s
+
+    expect(global.__SENTRY__.sdkInfo).to.exist;
+    expect(global.__SENTRY__.sdkInfo.name).to.equal('sentry.javascript.browser');
+    expect(global.__SENTRY__.sdkInfo.version).to.equal(SDK_VERSION);
+    expect(global.__SENTRY__.sdkInfo.packages).to.deep.equal([{ name: 'npm:@sentry/browser', version: SDK_VERSION }]);
+  });
+
   it('should use window.SENTRY_RELEASE to set release on initialization if available', () => {
     global.SENTRY_RELEASE = { id: 'foobar' };
     init({ dsn });

packages/core/src/request.ts

@@ -1,11 +1,14 @@
 import { Event, SentryRequest, Session } from '@sentry/types';
+import { getGlobalObject } from '@sentry/utils';
 
 import { API } from './api';
 
 /** Creates a SentryRequest from an event. */
 export function sessionToSentryRequest(session: Session, api: API): SentryRequest {
+  const { name, version } = getGlobalObject().__SENTRY__?.sdkInfo || {};
   const envelopeHeaders = JSON.stringify({
     sent_at: new Date().toISOString(),
+    sdk: { name, version },
   });
   const itemHeaders = JSON.stringify({
     type: 'session',
@@ -39,9 +42,12 @@ export function eventToSentryRequest(event: Event, api: API): SentryRequest {
   // deserialization. Instead, we only implement a minimal subset of the spec to
   // serialize events inline here.
   if (useEnvelope) {
+    const { name, version } = getGlobalObject().__SENTRY__?.sdkInfo || {};
+
     const envelopeHeaders = JSON.stringify({
       event_id: event.event_id,
       sent_at: new Date().toISOString(),
+      sdk: { name, version },
     });
     const itemHeaders = JSON.stringify({
       type: event.type,

packages/core/test/lib/request.test.ts

@@ -1,4 +1,5 @@
 import { Event, TransactionSamplingMethod } from '@sentry/types';
+import { getGlobalObject } from '@sentry/utils';
 
 import { API } from '../../src/api';
 import { eventToSentryRequest } from '../../src/request';
@@ -53,4 +54,22 @@ describe('eventToSentryRequest', () => {
       expect('dog' in envelope.event.tags).toBe(true);
     });
   });
+
+  it('adds sdk metadata to envelope header', () => {
+    getGlobalObject().__SENTRY__ = { sdkInfo: { name: 'sentry.javascript.browser', version: '12.31.12' } } as any;
+
+    const result = eventToSentryRequest(event as Event, api);
+
+    const [envelopeHeaderString, itemHeaderString, eventString] = result.body.split('\n');
+
+    const envelope = {
+      envelopeHeader: JSON.parse(envelopeHeaderString),
+      itemHeader: JSON.parse(itemHeaderString),
+      event: JSON.parse(eventString),
+    };
+
+    expect(envelope.envelopeHeader).toEqual(
+      expect.objectContaining({ sdk: { name: 'sentry.javascript.browser', version: '12.31.12' } }),
+    );
+  });
 });

packages/ember/addon/index.ts

@@ -5,7 +5,7 @@ import { macroCondition, isDevelopingApp } from '@embroider/macros';
 import { next } from '@ember/runloop';
 import { assert, warn } from '@ember/debug';
 import Ember from 'ember';
-import { timestampWithMs } from '@sentry/utils';
+import { setSDKInfo, timestampWithMs } from '@sentry/utils';
 
 declare module '@ember/debug' {
   export function assert(desc: string, test: unknown): void;
@@ -19,6 +19,7 @@ export function InitSentryForEmber(_runtimeConfig: BrowserOptions | undefined) {
   const initConfig = Object.assign({}, config.sentry, _runtimeConfig || {});
 
   createEmberEventProcessor();
+  setSDKInfo('sentry.javascript.ember', 'npm:@sentry/ember', SDK_VERSION);
 
   Sentry.init(initConfig);
 

packages/ember/tests/unit/init-test.ts

@@ -0,0 +1,20 @@
+import { module, test } from 'qunit';
+import * as Sentry from '@sentry/ember';
+import { getGlobalObject } from '@sentry/utils';
+
+const global = getGlobalObject<Window>();
+
+module('Unit | SDK initialization', function() {
+  test('adds SDK metadata globally', function(assert) {
+    // the SDK data is set when we import from @sentry/ember (and therefore run `addon/index.ts`) - it sets the ember
+    // part itself, and the browser part gets set when it imports from @sentry/browser - so no action is necessary here
+    // before we run the `assert`s
+
+    assert.equal(global.__SENTRY__?.sdkInfo?.name, 'sentry.javascript.ember');
+    assert.equal(global.__SENTRY__?.sdkInfo?.version, Sentry.SDK_VERSION);
+    assert.deepEqual(global.__SENTRY__?.sdkInfo?.packages, [
+      { name: 'npm:@sentry/browser', version: Sentry.SDK_VERSION },
+      { name: 'npm:@sentry/ember', version: Sentry.SDK_VERSION },
+    ]);
+  });
+});

packages/node/src/index.ts

@@ -42,6 +42,12 @@ export { NodeClient } from './client';
 export { defaultIntegrations, init, lastEventId, flush, close } from './sdk';
 export { SDK_NAME, SDK_VERSION } from './version';
 
+import { setSDKInfo } from '@sentry/utils';
+
+import { SDK_VERSION } from './version';
+
+setSDKInfo('sentry.javascript.node', 'npm:@sentry/node', SDK_VERSION, false);
+
 import { Integrations as CoreIntegrations } from '@sentry/core';
 import { getMainCarrier } from '@sentry/hub';
 import * as domain from 'domain';

packages/node/test/index.test.ts

@@ -11,6 +11,7 @@ import {
   init,
   NodeClient,
   Scope,
+  SDK_VERSION,
 } from '../src';
 import { NodeBackend } from '../src/backend';
 
@@ -270,6 +271,16 @@ describe('SentryNode', () => {
 });
 
 describe('SentryNode initialization', () => {
+  test('sets SDK info globally', () => {
+    // the SDK data is set when we import from (and therefore run) `../src/index.ts`, so no action is necessary here
+    // before we run the `expect`s
+
+    expect(global.__SENTRY__.sdkInfo).toBeDefined();
+    expect(global.__SENTRY__.sdkInfo.name).toEqual('sentry.javascript.node');
+    expect(global.__SENTRY__.sdkInfo.version).toEqual(SDK_VERSION);
+    expect(global.__SENTRY__.sdkInfo.packages).toEqual([{ name: 'npm:@sentry/node', version: SDK_VERSION }]);
+  });
+
   test('global.SENTRY_RELEASE is used to set release on initialization if available', () => {
     global.SENTRY_RELEASE = { id: 'foobar' };
     init({ dsn });

packages/react/src/index.ts

@@ -1,4 +1,7 @@
 import { addGlobalEventProcessor, SDK_VERSION } from '@sentry/browser';
+import { setSDKInfo } from '@sentry/utils';
+
+setSDKInfo('sentry.javascript.react', 'npm:@sentry/react', SDK_VERSION);
 
 /**
  * A global side effect that makes sure Sentry events that user

packages/react/test/init.test.tsx

@@ -0,0 +1,23 @@
+import { getGlobalObject } from '@sentry/utils';
+
+import * as Sentry from '../src/index';
+
+const global = getGlobalObject<Window>();
+
+describe('event SDK info', () => {
+  it('adds SDK metadata globally', () => {
+    // the SDK data is set when we import from (and therefore run) `../src/index.ts` - it sets the react part itself,
+    // and the browser part gets set when it imports from @sentry/browser - so no action is necessary here before we run
+    // the `expect`s
+
+    expect(global.__SENTRY__?.sdkInfo).toBeDefined();
+    expect(global.__SENTRY__?.sdkInfo?.name).toEqual('sentry.javascript.react');
+    expect(global.__SENTRY__?.sdkInfo?.version).toEqual(Sentry.SDK_VERSION);
+    expect(global.__SENTRY__?.sdkInfo?.packages).toEqual(
+      expect.arrayContaining([
+        { name: 'npm:@sentry/react', version: Sentry.SDK_VERSION },
+        { name: 'npm:@sentry/browser', version: Sentry.SDK_VERSION },
+      ]),
+    );
+  });
+});

packages/serverless/src/index.ts

@@ -5,3 +5,8 @@ export { AWSLambda, GCPFunction };
 
 export * from './awsservices';
 export * from '@sentry/node';
+
+import { SDK_VERSION } from '@sentry/node';
+import { setSDKInfo } from '@sentry/utils';
+
+setSDKInfo('sentry.javascript.serverless', 'npm:@sentry/serverless', SDK_VERSION);

packages/serverless/test/__mocks__/@sentry/node.ts

@@ -1,7 +1,7 @@
 const origSentry = jest.requireActual('@sentry/node');
 export const defaultIntegrations = origSentry.defaultIntegrations; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
 export const Handlers = origSentry.Handlers; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
-export const SDK_VERSION = '6.6.6';
+export const SDK_VERSION = origSentry.SDK_VERSION; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
 export const Severity = {
   Warning: 'warning',
 };

packages/serverless/test/awslambda.test.ts

@@ -1,4 +1,5 @@
 import { Event } from '@sentry/types';
+import { getGlobalObject } from '@sentry/utils';
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import { Callback, Handler } from 'aws-lambda';
@@ -341,6 +342,24 @@ describe('AWSLambda', () => {
   });
 
   describe('init()', () => {
+    it('sets SDK data globally', () => {
+      // the SDK data is set when we import from (and therefore run) `../src/index.ts` - it sets the serverless part itself,
+      // and the node part gets set when it imports from @sentry/node - so no action is necessary here before we run
+      // the `expect`s
+
+      const global = getGlobalObject();
+
+      expect(global.__SENTRY__?.sdkInfo).toBeDefined();
+      expect(global.__SENTRY__?.sdkInfo?.name).toEqual('sentry.javascript.serverless');
+      expect(global.__SENTRY__?.sdkInfo?.version).toEqual(Sentry.SDK_VERSION);
+      expect(global.__SENTRY__?.sdkInfo?.packages).toEqual(
+        expect.arrayContaining([
+          { name: 'npm:@sentry/serverless', version: Sentry.SDK_VERSION },
+          { name: 'npm:@sentry/node', version: Sentry.SDK_VERSION },
+        ]),
+      );
+    });
+
     test('enhance event with SDK info and correct mechanism value', async () => {
       expect.assertions(1);
 
@@ -381,10 +400,10 @@ describe('AWSLambda', () => {
             },
             {
               name: 'npm:@sentry/serverless',
-              version: '6.6.6',
+              version: Sentry.SDK_VERSION,
             },
           ],
-          version: '6.6.6',
+          version: Sentry.SDK_VERSION,
         },
       });
     });
@@ -416,10 +435,10 @@ describe('AWSLambda', () => {
           packages: [
             {
               name: 'npm:@sentry/serverless',
-              version: '6.6.6',
+              version: Sentry.SDK_VERSION,
             },
           ],
-          version: '6.6.6',
+          version: Sentry.SDK_VERSION,
         },
       });
     });