Typescript Core/Browser implementation

.eslintignore

@@ -4,4 +4,5 @@ example/
 vendor/
 test/
 scripts/
-
+packages/core/
+packages/browser/

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+*               @kamilogorek
+packages/*      @hazat

.gitignore

@@ -20,3 +20,5 @@ scratch/
 
 .idea
 *.sublime-*
+
+yarn-error.log

.npmignore

@@ -0,0 +1,13 @@
+build/
+docs/
+example/
+node_modules/
+packages/
+scripts/
+template/
+test/
+
+.*
+karma.*
+Makefile
+npm-debug.log

.travis.yml

@@ -1,6 +1,7 @@
 branches:
   only:
     - master
+
 sudo: false
 language: node_js
 node_js:
@@ -9,9 +10,30 @@ dist: trusty
 cache:
   directories:
   - node_modules
-addons:
-  chrome: stable
-  firefox: latest
-  sauce_connect: true
-script:
-  - npm run test && if [ "$TRAVIS_SECURE_ENV_VARS" == "true" ]; then npm run test:ci; else exit 0; fi
+before_install:
+  - curl -o- -L https://yarnpkg.com/install.sh | bash
+  - export PATH="$HOME/.yarn/bin:$PATH"
+
+matrix:
+  include:
+    - env: NAME="raven-js"
+      addons:
+        chrome: stable
+        firefox: latest
+        sauce_connect: true
+      script:
+        - npm run test && if [ "$TRAVIS_SECURE_ENV_VARS" == "true" ]; then npm run test:ci; else exit 0; fi
+    - env: NAME="@sentry/browser"
+      install: true
+      script:
+      - yarn link
+      - cd packages/core && yarn link && yarn install && yarn dist
+      - cd ../browser
+      - yarn remove @sentry/core # this has to be removed once we released the package
+      - yarn link "@sentry/core"
+      - yarn link "raven-js"
+      - yarn install && yarn test
+    - env: NAME="@sentry/core"
+      install: true
+      script:
+      - cd packages/core && yarn install && yarn test

.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
+    "recommendations": [
+        "esbenp.prettier-vscode"
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,20 @@
+{
+    "editor.tabSize": 2,
+    "editor.rulers": [90],
+    "[typescript]": {
+        "editor.formatOnSave": true
+    },
+    "[javascript]": {
+        "editor.formatOnSave": true
+    },
+    "prettier.typescriptEnable": [
+        "typescript",
+        "typescriptreact"
+    ],
+    "search.exclude": {
+        "**/node_modules": true,
+        "**/bower_components": true,
+        "**/dist/**": true
+    },
+    "tslint.autoFixOnSave": true,
+}

packages/.gitignore

@@ -0,0 +1,2 @@
+dist/
+coverage/

packages/browser/.prettierrc

@@ -0,0 +1,5 @@
+{
+    "trailingComma": "es5",
+    "singleQuote": true,
+    "printWidth": 90
+}

packages/browser/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## v0.1.0
+
+- Initial release

packages/browser/README.md

@@ -0,0 +1,58 @@
+<p align="center">
+    <a href="https://sentry.io" target="_blank" align="center">
+        <img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" width="280">
+    </a>
+<br/>
+    <h1>Sentry Browser SDK Package</h1>
+</p>
+
+[![npm version](https://img.shields.io/npm/v/@sentry/browser.svg)](https://www.npmjs.com/package/@sentry/browser)
+[![npm dm](https://img.shields.io/npm/dm/@sentry/browser.svg)](https://www.npmjs.com/package/@sentry/browser)
+[![npm dt](https://img.shields.io/npm/dt/@sentry/browser.svg)](https://www.npmjs.com/package/@sentry/browser)
+
+## General
+
+This package is meant to be used with the Core SDK package.
+
+## Usage
+
+First you have to create the core and `use` a corresponding SDK.
+```javascript
+import * as Sentry from '@sentry/core';
+import { Browser } from '@sentry/browser';
+
+Sentry.create('__DSN__')
+  .use(Browser)
+  .install();
+```
+
+After that you can call function on the global `sharedClient`:
+```javascript
+Sentry.getSharedClient().setTagsContext({ cordova: true });
+Sentry.getSharedClient().captureMessage('test message');
+Sentry.getSharedClient().captureBreadcrumb({ message: 'HOHOHOHO' });
+Sentry.getSharedClient().captureException(new Error('error'));
+```
+
+If you don't want to use a global static instance of Sentry, you can create one on your own:
+
+```javascript
+const client = await new Sentry.Client(dsn).use(MockAdapter).install()
+client.setTagsContext({ cordova: true });
+client.captureMessage('test message');
+client.captureBreadcrumb({ message: 'HOHOHOHO' });
+
+// OR
+
+new Sentry.Client('__DSN__')
+  .use(MockAdapter)
+  .install()
+  .then(client => {
+    client.setTagsContext({ cordova: true });
+    client.captureMessage('test message');
+    client.captureBreadcrumb({ message: 'HOHOHOHO' });
+  });
+```
+
+Notice, `install()` is a `Promise` but we internally wait until it is resolved,
+so it is save to call other function without waiting for it.

packages/browser/__tests__/browser.no-jest.ts

@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/core';
+import { SentryBrowser } from '../lib/SentryBrowser';
+
+// install() returns a promise after init
+Sentry.create('https://53039209a22b4ec1bcc296a3c9fdecd6@sentry.io/4291')
+  .use(SentryBrowser)
+  .install()
+  .then(client => {
+    client.setTagsContext({ cordova: true });
+    client.captureBreadcrumb({ message: 'HOHOHOHO' });
+  });
+
+// This should also work because we internally await for adapter install
+Sentry.getSharedClient().captureMessage('PICKLE RIIIICK!');
+Sentry.getSharedClient().captureException(new Error('YOYOYOY'));
+
+// throw new Error('YP Test');

packages/browser/__tests__/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+	<title></title>
+</head>
+<body>
+	<script src="../dist/bundle.js"></script>
+</body>
+</html>

packages/browser/__tests__/index.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+/// <reference types="jest" />
+import * as Sentry from '@sentry/core';
+import * as fs from 'fs';
+import * as http from 'http';
+import * as path from 'path';
+import * as Puppeteer from 'puppeteer';
+import { SentryBrowser } from '../index';
+
+describe('Browser Interface', () => {
+  test('sending a message', async done => {
+    let countExpects = 0;
+    const expectedAssertions = 2;
+    expect.assertions(expectedAssertions);
+
+    const server = http
+      .createServer((request, response) => {
+        if (request.url === '/index.html') {
+          response.writeHead(200, { 'Content-Type': 'text/html' });
+          const contents = fs.readFileSync(path.join(__dirname, './index.html'));
+          response.write(contents);
+        }
+        if (request.url === '/dist/bundle.js') {
+          response.writeHead(200, { 'Content-Type': 'text/javscript' });
+          const contents = fs.readFileSync(path.join(__dirname, '../dist/bundle.js'));
+          response.write(contents);
+        }
+        response.end();
+      })
+      .listen(8999);
+
+    const browser = await Puppeteer.launch({ headless: true });
+    const page = await browser.newPage();
+
+    page.on('request', async request => {
+      // @ts-ignore
+      if (request.resourceType === 'xhr') {
+        const data = JSON.parse(request.postData as any);
+        if (data.exception) {
+          expect(data.exception).not.toBeUndefined();
+        } else {
+          expect(data.message).toBe('PICKLE RIIIICK!');
+        }
+        countExpects++;
+      }
+      if (countExpects === expectedAssertions) {
+        await browser.close();
+        done();
+      }
+    });
+    await page.goto('http://localhost:8999/index.html');
+    server.close();
+  });
+});

packages/browser/index.ts

@@ -0,0 +1 @@
+export { SentryBrowser, ISentryBrowserOptions } from './lib/SentryBrowser';

packages/browser/lib/SentryBrowser.ts

@@ -0,0 +1,96 @@
+import { Client, Event, IAdapter, IBreadcrumb, IUser } from '@sentry/core';
+declare function require(path: string): any;
+const Raven = require('raven-js');
+
+export interface ISentryBrowserOptions {
+  allowSecretKey?: boolean;
+  allowDuplicates?: boolean;
+}
+
+export class SentryBrowser implements IAdapter {
+  private client: Client;
+
+  constructor(client: Client, public options: ISentryBrowserOptions = {}) {
+    this.client = client;
+  }
+
+  public install(): Promise<boolean> {
+    Raven.config(this.client.dsn.getDsn(false), this.options).install();
+    return Promise.resolve(true);
+  }
+
+  public getRaven() {
+    return Raven;
+  }
+
+  public setOptions(options: ISentryBrowserOptions) {
+    Object.assign(this.options, options);
+    Object.assign(Raven._globalOptions, this.options);
+    return this;
+  }
+
+  public captureException(exception: Error) {
+    return new Promise<Event>((resolve, reject) => {
+      const ravenSendRequest = Raven._sendProcessedPayload;
+      Raven._sendProcessedPayload = (data: any) => {
+        Raven._sendProcessedPayload = ravenSendRequest;
+        resolve(data);
+      };
+      Raven.captureException(exception);
+    });
+  }
+
+  public captureMessage(message: string) {
+    return new Promise<Event>((resolve, reject) => {
+      const ravenSendRequest = Raven._sendProcessedPayload;
+      Raven._sendProcessedPayload = (data: any) => {
+        Raven._sendProcessedPayload = ravenSendRequest;
+        resolve(data);
+      };
+      Raven.captureMessage(message);
+    });
+  }
+
+  public setBreadcrumbCallback(callback: (crumb: IBreadcrumb) => void) {
+    Raven.setBreadcrumbCallback(callback);
+  }
+
+  public captureBreadcrumb(crumb: IBreadcrumb) {
+    return new Promise<IBreadcrumb>((resolve, reject) => {
+      Raven.captureBreadcrumb(crumb);
+      resolve(crumb);
+    });
+  }
+
+  public send(event: any) {
+    return new Promise<Event>((resolve, reject) => {
+      Raven._sendProcessedPayload(event, (error: any) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(event);
+      });
+    });
+  }
+
+  public setUserContext(user?: IUser) {
+    Raven.setUserContext(user);
+    return this;
+  }
+
+  public setTagsContext(tags?: { [key: string]: any }) {
+    Raven.setTagsContext(tags);
+    return this;
+  }
+
+  public setExtraContext(extra?: { [key: string]: any }) {
+    Raven.setExtraContext(extra);
+    return this;
+  }
+
+  public clearContext() {
+    Raven.clearContext();
+    return this;
+  }
+}