feat: Expose sdkinfo, Add auth header

Author: HazAT

packages/browser/src/backend.ts

@@ -7,7 +7,7 @@ import { FetchTransport, XHRTransport } from './transports';
 
 /**
  * Configuration options for the Sentry Browser SDK.
- * @see BrowserClient for more information.
+ * @see BrowserClient afor more information.
  */
 export interface BrowserOptions extends Options {
   /**

packages/browser/src/client.ts

@@ -22,7 +22,7 @@ export class BrowserClient extends BaseClient<BrowserBackend, BrowserOptions> {
   /**
    * @inheritDoc
    */
-  protected getSdkInfo(): SdkInfo {
+  public getSdkInfo(): SdkInfo {
     return {
       name: 'sentry-browser',
       version: Raven.VERSION,

packages/core/src/base.ts

@@ -206,8 +206,10 @@ export abstract class BaseClient<B extends Backend, O extends Options>
     return this.options;
   }
 
-  /** Returns the current used SDK version and name. */
-  protected abstract getSdkInfo(): SdkInfo;
+  /**
+   * @inheritDoc
+   */
+  public abstract getSdkInfo(): SdkInfo;
 
   /** Returns the current backend. */
   protected getBackend(): B {

packages/core/src/interfaces.ts

@@ -2,6 +2,7 @@ import { Scope } from '@sentry/hub';
 import {
   Breadcrumb,
   Integration,
+  SdkInfo,
   SentryEvent,
   SentryResponse,
   Transport,
@@ -210,6 +211,9 @@ export interface Client<O extends Options = Options> {
 
   /** Returns the current options. */
   getOptions(): O;
+
+  /** Returns the current used SDK version and name. */
+  getSdkInfo(): SdkInfo;
 }
 
 /**

packages/node/src/backend.ts

@@ -1,22 +1,25 @@
 import { Backend, DSN, Options, SentryError } from '@sentry/core';
 import { addBreadcrumb, captureEvent } from '@sentry/minimal';
-import { SentryEvent } from '@sentry/types';
-import {
-  HTTPSTransport,
-  HTTPTransport,
-  Raven,
-  SendMethod,
-  Transport,
-} from './raven';
-
-/** Original Raven send function. */
-const sendRavenEvent = Raven.send.bind(Raven) as SendMethod;
+import { SentryEvent, SentryResponse } from '@sentry/types';
+import { Raven } from './raven';
+import { HTTPSTransport, HTTPTransport } from './transports';
 
 /** Extension to the Function type. */
 interface FunctionExt extends Function {
   __SENTRY_CAPTURE__?: boolean;
 }
 
+/** Prepares an event so it can be send with raven-js. */
+function normalizeEvent(ravenEvent: any): SentryEvent {
+  const event = ravenEvent;
+  // tslint:disable-next-line:no-unsafe-any
+  if (ravenEvent.exception && !ravenEvent.exception.values) {
+    // tslint:disable-next-line:no-unsafe-any
+    event.exception = { values: ravenEvent.exception };
+  }
+  return event as SentryEvent;
+}
+
 /**
  * Configuration options for the Sentry Node SDK.
  * @see NodeClient for more information.
@@ -85,9 +88,9 @@ export class NodeBackend implements Backend {
     // actual submission.
     Raven.send = (event, callback) => {
       if (callback && (callback as FunctionExt).__SENTRY_CAPTURE__) {
-        callback(event);
+        callback(normalizeEvent(event));
       } else {
-        captureEvent(event);
+        captureEvent(normalizeEvent(event));
         // TODO: Check if this is fine
         if (callback) {
           callback(event);
@@ -121,13 +124,22 @@ export class NodeBackend implements Backend {
   /**
    * @inheritDoc
    */
-  public async sendEvent(event: SentryEvent): Promise<number> {
-    return new Promise<number>(resolve => {
-      sendRavenEvent(event, error => {
-        // TODO: Check the response status code
-        resolve(error ? 500 : 200);
-      });
-    });
+  public async sendEvent(event: SentryEvent): Promise<SentryResponse> {
+    let dsn: DSN;
+
+    if (!this.options.dsn) {
+      throw new SentryError('Cannot sendEvent without a valid DSN');
+    } else {
+      dsn = new DSN(this.options.dsn);
+    }
+
+    const transport = this.options.transport
+      ? new this.options.transport({ dsn })
+      : dsn.protocol === 'http'
+        ? new HTTPTransport({ dsn })
+        : new HTTPSTransport({ dsn });
+
+    return transport.send(event);
   }
 
   /**
@@ -143,25 +155,4 @@ export class NodeBackend implements Backend {
   public storeScope(): void {
     // Noop
   }
-
-  /**
-   * Set the transport module used for submitting events.
-   *
-   * This can be set to modules like "http" or "https" or any other object that
-   * provides a `request` method with options.
-   *
-   * @param transport The transport to use for submitting events.
-   */
-  public setTransport(transport: Transport): void {
-    const dsn = this.options.dsn;
-    if (!dsn) {
-      return;
-    }
-    const dsnObject = new DSN(dsn);
-
-    Raven.transport =
-      dsnObject.protocol === 'http'
-        ? new HTTPTransport({ transport })
-        : new HTTPSTransport({ transport });
-  }
 }

packages/node/src/client.ts

@@ -21,7 +21,7 @@ export class NodeClient extends BaseClient<NodeBackend, NodeOptions> {
   /**
    * @inheritDoc
    */
-  protected getSdkInfo(): SdkInfo {
+  public getSdkInfo(): SdkInfo {
     return {
       name: 'sentry-node',
       version: Raven.version,

packages/node/src/index.ts

@@ -4,9 +4,11 @@ export {
   SdkInfo,
   SentryEvent,
   SentryException,
+  SentryResponse,
   Severity,
   StackFrame,
   Stacktrace,
+  Status,
   Thread,
   User,
 } from '@sentry/types';
@@ -28,3 +30,6 @@ export { init } from './sdk';
 
 import * as Integrations from './integrations';
 export { Integrations };
+
+import * as Transports from './transports';
+export { Transports };

packages/node/src/raven.ts

@@ -3,21 +3,6 @@ import * as RavenNode from 'raven';
 
 export type SendMethod = (event: SentryEvent, cb?: (err: any) => void) => void;
 
-/** A HTTP transport module. */
-export interface Transport {
-  request(options: object | string): void;
-}
-
-/** A Raven transport wrapper. */
-export interface RavenTransport {
-  send(): void;
-}
-
-/** A constructor class that creates a RavenTransport. */
-export interface TransportClass {
-  new (options: { transport: Transport }): RavenTransport;
-}
-
 /** Provides access to internal raven functionality. */
 export interface RavenInternal {
   captureBreadcrumb(breadcrumb: Breadcrumb): void;
@@ -26,7 +11,6 @@ export interface RavenInternal {
   config(dsn: string, options: object): RavenInternal;
   install(onFatalError?: (error: Error) => void): void;
   send: SendMethod;
-  transport: RavenTransport;
   version: string;
   // TODO: Remove once integrations are ported
   onFatalError(error: Error): void;
@@ -37,12 +21,3 @@ export interface RavenInternal {
 /** Casted raven instance with access to internal functions. */
 // tslint:disable-next-line:variable-name
 export const Raven: RavenInternal = RavenNode as any;
-
-/** Interface for transports exported by RavenNode. */
-interface Transports {
-  HTTPSTransport: TransportClass;
-  HTTPTransport: TransportClass;
-}
-
-export const { HTTPSTransport, HTTPTransport } = (RavenNode as any)
-  .transports as Transports;

packages/node/src/transports/base.ts

@@ -2,12 +2,14 @@ import { DSN, SentryError } from '@sentry/core';
 import {
   SentryEvent,
   SentryResponse,
+  Status,
   Transport,
   TransportOptions as BaseOptions,
 } from '@sentry/types';
 import { serialize } from '@sentry/utils/src/object';
 import * as http from 'http';
 import * as https from 'https';
+import { getDefaultHub, NodeClient } from '../index';
 
 /** TODO */
 export interface HTTPRequest {
@@ -41,13 +43,37 @@ export abstract class BaseTransport implements Transport {
     this.dsn = new DSN(options.dsn);
   }
 
+  /** TODO */
+  private getAuthHeader(): string {
+    const header = ['Sentry sentry_version=7'];
+    header.push(`sentry_timestamp=${new Date().getTime()}`);
+    const client = getDefaultHub().getClient() as NodeClient;
+    if (client) {
+      header.push(
+        `sentry_client=${client.getSdkInfo().name}/${
+          client.getSdkInfo().version
+        }`,
+      );
+    }
+    header.push(`sentry_key=${this.dsn.user}`);
+    if (this.dsn.pass) {
+      header.push(`sentry_secret=${this.dsn.pass}`);
+    }
+    return header.join(', ');
+  }
+
   /**
    * TODO
    */
   protected getRequestOptions(): http.RequestOptions {
+    const headers = {
+      'X-Sentry-Auth': this.getAuthHeader(),
+      ...this.options.headers,
+    };
+
     return {
       agent: this.client,
-      headers: this.options.headers,
+      headers,
       hostname: this.dsn.host,
       method: 'POST',
       path: `${this.dsn.path}/api/${this.dsn.projectId}/store/`,
@@ -68,8 +94,9 @@ export abstract class BaseTransport implements Transport {
           res.setEncoding('utf8');
           if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
             resolve({
+              code: res.statusCode,
               event_id: event.event_id,
-              status: res.statusCode,
+              status: Status.fromHttpCode(res.statusCode),
             });
           } else {
             const reason = res.headers['x-sentry-error'];

packages/node/test/index.test.ts

@@ -1,15 +1,6 @@
 import * as domain from 'domain';
 import * as RavenNode from 'raven';
 
-// -----------------------------------------------------------------------------
-// It's important that we stub this before we import the backend
-jest
-  .spyOn(RavenNode as any, 'send')
-  .mockImplementation((_: SentryEvent, cb: () => void) => {
-    cb();
-  });
-// -----------------------------------------------------------------------------
-
 import {
   addBreadcrumb,
   captureEvent,
@@ -22,6 +13,7 @@ import {
   NodeClient,
   Scope,
   SentryEvent,
+  SentryResponse,
 } from '../src';
 
 const dsn = 'https://[email protected]/4291';
@@ -71,12 +63,12 @@ describe('SentryNode', () => {
   });
 
   describe('breadcrumbs', () => {
-    let s: jest.Mock<(event: SentryEvent) => Promise<number>>;
+    let s: jest.Mock<(event: SentryEvent) => Promise<SentryResponse>>;
 
     beforeEach(() => {
       s = jest
         .spyOn(NodeBackend.prototype, 'sendEvent')
-        .mockImplementation(async () => Promise.resolve(200));
+        .mockImplementation(async () => Promise.resolve({ code: 200 }));
     });
 
     afterEach(() => {
@@ -111,12 +103,12 @@ describe('SentryNode', () => {
   });
 
   describe('capture', () => {
-    let s: jest.Mock<(event: SentryEvent) => Promise<number>>;
+    let s: jest.Mock<(event: SentryEvent) => Promise<SentryResponse>>;
 
     beforeEach(() => {
       s = jest
         .spyOn(NodeBackend.prototype, 'sendEvent')
-        .mockImplementation(async () => Promise.resolve(200));
+        .mockImplementation(async () => Promise.resolve({ code: 200 }));
     });
 
     afterEach(() => {
@@ -130,10 +122,10 @@ describe('SentryNode', () => {
           afterSend: (event: SentryEvent) => {
             expect(event.tags).toEqual({ test: '1' });
             expect(event.exception).not.toBeUndefined();
-            expect(event.exception![0]).not.toBeUndefined();
-            expect(event.exception![0].type).toBe('Error');
-            expect(event.exception![0].value).toBe('test');
-            expect(event.exception![0].stacktrace).toBeTruthy();
+            expect(event.exception!.values[0]).not.toBeUndefined();
+            expect(event.exception!.values[0].type).toBe('Error');
+            expect(event.exception!.values[0].value).toBe('test');
+            expect(event.exception!.values[0].stacktrace).toBeTruthy();
             done();
           },
           dsn,

packages/node/test/transports.test.ts

@@ -0,0 +1,16 @@
+import { captureException, init, SentryEvent } from '../src';
+
+const dsn = 'https://[email protected]/50622';
+
+describe('HTTPTransport', () => {
+  test('captureEvent', done => {
+    init({
+      afterSend: (event: SentryEvent) => {
+        expect(event.message).toBe('test');
+        done();
+      },
+      dsn,
+    });
+    captureException(new Error('wat'));
+  });
+});