@honeybadger-io/js 4.0.0-beta.5 → 4.0.2

package/dist/server/honeybadger.js

@@ -1,20 +1,21 @@
 'use strict';
 
-var https = require('https');
-var http = require('http');
-var url = require('url');
 var os = require('os');
 var domain = require('domain');
 var fs = require('fs');
+var util = require('util');
+var url = require('url');
+var http = require('http');
+var https = require('https');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
-var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
-var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
 var domain__default = /*#__PURE__*/_interopDefaultLegacy(domain);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -56,7 +57,45 @@ var __assign = function() {
         return t;
     };
     return __assign.apply(this, arguments);
-};
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
 
 var UNKNOWN_FUNCTION = '<unknown>';
 /**
@@ -238,24 +277,31 @@ function makeBacktrace(stack, shift) {
         return [];
     }
 }
-function getSourceForBacktrace(backtrace, getSourceFileHandler, cb) {
-    if (!getSourceFileHandler || !backtrace || !backtrace.length) {
-        cb([]);
-        return;
-    }
-    var result = [];
-    var getSourceFromFile = function (index) {
-        if (index === void 0) { index = 0; }
-        if (!backtrace.length) {
-            return cb(result);
-        }
-        var trace = backtrace.splice(0)[index];
-        getSourceFileHandler(trace.file, (function (fileContent) {
-            result[index] = getSourceCodeSnippet(fileContent, trace.number);
-            getSourceFromFile(index + 1);
-        }));
-    };
-    getSourceFromFile();
+function getSourceForBacktrace(backtrace, getSourceFileHandler) {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, index, trace, fileContent;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = [];
+                    if (!getSourceFileHandler || !backtrace || !backtrace.length) {
+                        return [2 /*return*/, result];
+                    }
+                    index = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!backtrace.length) return [3 /*break*/, 3];
+                    trace = backtrace.splice(0)[index];
+                    return [4 /*yield*/, getSourceFileHandler(trace.file)];
+                case 2:
+                    fileContent = _a.sent();
+                    result[index] = getSourceCodeSnippet(fileContent, trace.number);
+                    index++;
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, result];
+            }
+        });
+    });
 }
 function runBeforeNotifyHandlers(notice, handlers) {
     var result = true;
@@ -415,8 +461,8 @@ function makeNotice(thing) {
     }
     return notice;
 }
-function endpoint(config, path) {
-    var endpoint = config.endpoint.trim().replace(/\/$/, '');
+function endpoint(base, path) {
+    var endpoint = base.trim().replace(/\/$/, '');
     path = path.trim().replace(/(^\/|\/$)/g, '');
     return "".concat(endpoint, "/").concat(path);
 }
@@ -548,6 +594,9 @@ function getSourceCodeSnippet(fileData, lineNumber, sourceRadius) {
     }
     return result;
 }
+function isBrowserConfig(config) {
+    return config.async !== undefined;
+}
 
 var GlobalStore$1 = /** @class */ (function () {
     function GlobalStore(store) {
@@ -570,14 +619,14 @@ var GlobalStore$1 = /** @class */ (function () {
 var notifier = {
     name: 'honeybadger-js',
     url: 'https://github.com/honeybadger-io/honeybadger-js',
-    version: '4.0.0-beta.5'
+    version: '4.0.2'
 };
 // Split at commas and spaces
 var TAG_SEPARATOR = /,|\s+/;
 // Checks for non-blank characters
 var NOT_BLANK = /\S/;
 var Client = /** @class */ (function () {
-    function Client(opts) {
+    function Client(opts, transport) {
         if (opts === void 0) { opts = {}; }
         this.__pluginsExecuted = false;
         this.__store = null;
@@ -587,11 +636,9 @@ var Client = /** @class */ (function () {
         // First, we go with the global (shared) store.
         // Webserver middleware can then switch to the AsyncStore for async context tracking.
         this.__store = new GlobalStore$1({ context: {}, breadcrumbs: [] });
+        this.__transport = transport;
         this.logger = logger(this);
     }
-    Client.prototype.factory = function (_opts) {
-        throw (new Error('Must implement __factory in subclass'));
-    };
     Client.prototype.getVersion = function () {
         return notifier.version;
     };
@@ -665,6 +712,9 @@ var Client = /** @class */ (function () {
             this.logger.warn('could not send error report: no API key has been configured', notice);
             preConditionError = new Error('missing API key');
         }
+        // we need to have the source file data before the beforeNotifyHandlers,
+        // in case they modify them
+        var sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(function (trace) { return shallowClone(trace); }) : null;
         var beforeNotifyResult = runBeforeNotifyHandlers(notice, this.__beforeNotifyHandlers);
         if (!preConditionError && !beforeNotifyResult) {
             this.logger.debug('skipping error report: beforeNotify handlers returned false', notice);
@@ -684,14 +734,41 @@ var Client = /** @class */ (function () {
         });
         var breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
         notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs.slice() : [];
-        // we need to have the source file data before the beforeNotifyHandlers,
-        // in case they modify them
-        var sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(function (trace) { return shallowClone(trace); }) : null;
-        getSourceForBacktrace(sourceCodeData, this.__getSourceFileHandler, function (sourcePerTrace) {
+        getSourceForBacktrace(sourceCodeData, this.__getSourceFileHandler)
+            .then(function (sourcePerTrace) {
             sourcePerTrace.forEach(function (source, index) {
                 notice.backtrace[index].source = source;
             });
-            _this.__send(notice);
+            var payload = _this.__buildPayload(notice);
+            _this.__transport
+                .send({
+                headers: {
+                    'X-API-Key': _this.config.apiKey,
+                    'Content-Type': 'application/json',
+                    'Accept': 'text/json, application/json'
+                },
+                method: 'POST',
+                endpoint: endpoint(_this.config.endpoint, '/v1/notices/js'),
+                maxObjectDepth: _this.config.maxObjectDepth,
+                logger: _this.logger,
+                async: isBrowserConfig(_this.config) ? _this.config.async : undefined,
+            }, payload)
+                .then(function (res) {
+                if (res.statusCode !== 201) {
+                    runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, new Error("Bad HTTP response: ".concat(res.statusCode)));
+                    _this.logger.warn("Error report failed: unknown response from server. code=".concat(res.statusCode));
+                    return;
+                }
+                var uuid = JSON.parse(res.body).id;
+                runAfterNotifyHandlers(merge(notice, {
+                    id: uuid
+                }), _this.__afterNotifyHandlers);
+                _this.logger.info("Error report sent \u26A1 https://app.honeybadger.io/notice/".concat(uuid));
+            })
+                .catch(function (err) {
+                _this.logger.error('Error report failed: an unknown error occurred.', "message=".concat(err.message));
+                runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, err);
+            });
         });
         return true;
     };
@@ -759,7 +836,7 @@ var Client = /** @class */ (function () {
         }
         var context = this.__getStoreContentsOrDefault().context;
         var noticeTags = this.__constructTags(notice.tags);
-        var contextTags = this.__constructTags(context["tags"]);
+        var contextTags = this.__constructTags(context['tags']);
         var configTags = this.__constructTags(this.config.tags);
         // Turning into a Set will remove duplicates
         var tags = noticeTags.concat(contextTags).concat(configTags);
@@ -811,9 +888,6 @@ var Client = /** @class */ (function () {
         }
         return (this.config.environment && this.config.developmentEnvironments.includes(this.config.environment));
     };
-    Client.prototype.__send = function (_notice) {
-        throw (new Error('Must implement send in subclass'));
-    };
     Client.prototype.__buildPayload = function (notice) {
         var headers = filter(notice.headers, this.config.filters) || {};
         var cgiData = filter(__assign(__assign({}, notice.cgiData), formatCGIData(headers, 'HTTP_')), this.config.filters);
@@ -869,59 +943,86 @@ var Client = /** @class */ (function () {
     return Client;
 }());
 
+var readFile = util.promisify(fs__default["default"].readFile);
 function fatallyLogAndExit(err) {
     console.error('[Honeybadger] Exiting process due to uncaught exception');
     console.error(err.stack || err);
     process.exit(1);
 }
-function getStats(cb) {
-    var load = os__default["default"].loadavg(), stats = {
-        load: {
-            one: load[0],
-            five: load[1],
-            fifteen: load[2]
-        },
-        mem: {}
-    };
-    if (fs__default["default"].existsSync('/proc/meminfo')) {
-        return fs__default["default"].readFile('/proc/meminfo', 'utf8', parseStats);
-    }
-    fallback();
-    function parseStats(err, memData) {
-        if (err)
-            return fallback();
-        // The first four lines, in order, are Total, Free, Buffers, Cached.
-        // @TODO: Figure out if there's a way to only read these lines
-        var data = memData.split('\n').slice(0, 4);
-        var results = data.map(function (i) {
-            return parseInt(/\s+(\d+)\skB/i.exec(i)[1], 10) / 1024.0;
+function getStats() {
+    return __awaiter(this, void 0, void 0, function () {
+        var load, stats, fallback, memData, data, results;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    load = os__default["default"].loadavg();
+                    stats = {
+                        load: {
+                            one: load[0],
+                            five: load[1],
+                            fifteen: load[2]
+                        },
+                        mem: {}
+                    };
+                    fallback = function () {
+                        stats.mem = {
+                            free: os__default["default"].freemem(),
+                            total: os__default["default"].totalmem()
+                        };
+                    };
+                    if (!fs__default["default"].existsSync('/proc/meminfo')) {
+                        fallback();
+                        return [2 /*return*/, stats];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, readFile('/proc/meminfo', 'utf8')
+                        // The first four lines, in order, are Total, Free, Buffers, Cached.
+                        // @TODO: Figure out if there's a way to only read these lines
+                    ];
+                case 2:
+                    memData = _a.sent();
+                    data = memData.split('\n').slice(0, 4);
+                    results = data.map(function (i) {
+                        return parseInt(/\s+(\d+)\skB/i.exec(i)[1], 10) / 1024.0;
+                    });
+                    stats.mem = {
+                        total: results[0],
+                        free: results[1],
+                        buffers: results[2],
+                        cached: results[3],
+                        free_total: results[1] + results[2] + results[3]
+                    };
+                    return [3 /*break*/, 4];
+                case 3:
+                    _a.sent();
+                    fallback();
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/, stats];
+            }
         });
-        stats.mem = {
-            total: results[0],
-            free: results[1],
-            buffers: results[2],
-            cached: results[3],
-            free_total: results[1] + results[2] + results[3]
-        };
-        return cb(stats);
-    }
-    function fallback() {
-        stats.mem = {
-            free: os__default["default"].freemem(),
-            total: os__default["default"].totalmem()
-        };
-        return cb(stats);
-    }
+    });
 }
 /**
  * Get source file if possible, used to build `notice.backtrace.source`
  *
  * @param path to source code
- * @param cb callback with fileContent
  */
-function getSourceFile(path, cb) {
-    fs__default["default"].readFile(path, 'utf-8', function (err, data) {
-        cb(err ? null : data);
+function getSourceFile(path) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, readFile(path, 'utf-8')];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
     });
 }
 
@@ -954,12 +1055,15 @@ function asyncHandler(handler, hb) {
         hb.__setStore(AsyncStore);
         return new Promise(function (resolve, reject) {
             AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+                var timeoutHandler = setupTimeoutWarning(hb, context);
                 try {
                     handler(event, context)
                         .then(resolve)
-                        .catch(function (err) { return reportToHoneybadger(hb, err, reject); });
+                        .catch(function (err) { return reportToHoneybadger(hb, err, reject); })
+                        .finally(function () { return clearTimeout(timeoutHandler); });
                 }
                 catch (err) {
+                    clearTimeout(timeoutHandler);
                     reportToHoneybadger(hb, err, reject);
                 }
             });
@@ -970,8 +1074,10 @@ function syncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context, cb) {
         hb.__setStore(AsyncStore);
         AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+            var timeoutHandler = setupTimeoutWarning(hb, context);
             try {
                 handler(event, context, function (error, result) {
+                    clearTimeout(timeoutHandler);
                     if (error) {
                         return reportToHoneybadger(hb, error, cb);
                     }
@@ -979,11 +1085,24 @@ function syncHandler(handler, hb) {
                 });
             }
             catch (err) {
+                clearTimeout(timeoutHandler);
                 reportToHoneybadger(hb, err, cb);
             }
         });
     };
 }
+function shouldReportTimeoutWarning(hb, context) {
+    return typeof context.getRemainingTimeInMillis === 'function' && !!(hb.config.reportTimeoutWarning);
+}
+function setupTimeoutWarning(hb, context) {
+    if (!shouldReportTimeoutWarning(hb, context)) {
+        return;
+    }
+    var delay = context.getRemainingTimeInMillis() - (hb.config.timeoutWarningThresholdMs);
+    return setTimeout(function () {
+        hb.notify("".concat(context.functionName, "[").concat(context.functionVersion, "] may have timed out"));
+    }, delay > 0 ? delay : 0);
+}
 function lambdaHandler(handler) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     var hb = this;
@@ -1096,12 +1215,69 @@ function errorHandler(err, req, _res, next) {
     }
 }
 
-var kHoneybadgerStore = Symbol.for("kHoneybadgerStore");
+var ServerTransport = /** @class */ (function () {
+    function ServerTransport() {
+    }
+    ServerTransport.prototype.send = function (options, payload) {
+        var _this = this;
+        var protocol = new url.URL(options.endpoint).protocol;
+        var transport = (protocol === 'http:' ? http__default["default"] : https__default["default"]);
+        return new Promise(function (resolve, reject) {
+            var promise;
+            // this should not be here. it should be done before reaching the transport layer
+            // it could be inside a beforeNotifyHandler, but is not possible at the moment because those handlers are synchronous
+            if (_this.isNoticePayload(payload)) {
+                promise = _this.appendMetadata(payload);
+            }
+            else {
+                promise = Promise.resolve();
+            }
+            promise.then(function () {
+                var httpOptions = {
+                    method: options.method,
+                    headers: options.headers,
+                };
+                var data = undefined;
+                if (payload) {
+                    data = Buffer.from(JSON.stringify(sanitize(payload, options.maxObjectDepth)), 'utf8');
+                    httpOptions.headers['Content-Length'] = data.length;
+                }
+                var req = transport.request(options.endpoint, httpOptions, function (res) {
+                    options.logger.debug("statusCode: ".concat(res.statusCode));
+                    var body = '';
+                    res.on('data', function (chunk) {
+                        body += chunk;
+                    });
+                    res.on('end', function () { return resolve({ statusCode: res.statusCode, body: body }); });
+                });
+                req.on('error', function (err) { return reject(err); });
+                if (data) {
+                    req.write(data);
+                }
+                req.end();
+            });
+        });
+    };
+    ServerTransport.prototype.isNoticePayload = function (payload) {
+        return payload && payload.error !== undefined;
+    };
+    ServerTransport.prototype.appendMetadata = function (payload) {
+        payload.server.pid = process.pid;
+        return getStats()
+            .then(function (stats) {
+            payload.server.stats = stats;
+        });
+    };
+    return ServerTransport;
+}());
+
+var kHoneybadgerStore = Symbol.for('kHoneybadgerStore');
 var Honeybadger = /** @class */ (function (_super) {
     __extends(Honeybadger, _super);
     function Honeybadger(opts) {
         if (opts === void 0) { opts = {}; }
-        var _this = _super.call(this, __assign({ afterUncaught: fatallyLogAndExit, projectRoot: process.cwd(), hostname: os__default["default"].hostname() }, opts)) || this;
+        var _a;
+        var _this = _super.call(this, __assign({ afterUncaught: fatallyLogAndExit, projectRoot: process.cwd(), hostname: os__default["default"].hostname() }, opts), new ServerTransport()) || this;
         /** @internal */
         _this.__beforeNotifyHandlers = [
             function (notice) {
@@ -1114,6 +1290,10 @@ var Honeybadger = /** @class */ (function (_super) {
                 });
             }
         ];
+        // serverless defaults
+        var config = _this.config;
+        config.reportTimeoutWarning = (_a = config.reportTimeoutWarning) !== null && _a !== void 0 ? _a : true;
+        config.timeoutWarningThresholdMs = config.timeoutWarningThresholdMs || 50;
         _this.__getSourceFileHandler = getSourceFile.bind(_this);
         _this.errorHandler = errorHandler.bind(_this);
         _this.requestHandler = requestHandler.bind(_this);
@@ -1121,51 +1301,27 @@ var Honeybadger = /** @class */ (function (_super) {
         return _this;
     }
     Honeybadger.prototype.factory = function (opts) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new Honeybadger(opts);
     };
-    /** @internal */
-    Honeybadger.prototype.__send = function (notice) {
+    Honeybadger.prototype.configure = function (opts) {
+        if (opts === void 0) { opts = {}; }
+        return _super.prototype.configure.call(this, opts);
+    };
+    Honeybadger.prototype.checkIn = function (id) {
         var _this = this;
-        var protocol = new url.URL(this.config.endpoint).protocol;
-        var transport = (protocol === "http:" ? http__default["default"] : https__default["default"]);
-        var payload = this.__buildPayload(notice);
-        payload.server.pid = process.pid;
-        getStats(function (stats) {
-            payload.server.stats = stats;
-            var data = Buffer.from(JSON.stringify(sanitize(payload, _this.config.maxObjectDepth)), 'utf8');
-            var options = {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Content-Length': data.length,
-                    'X-API-Key': _this.config.apiKey
-                }
-            };
-            var req = transport.request(endpoint(_this.config, '/v1/notices/js'), options, function (res) {
-                _this.logger.debug("statusCode: ".concat(res.statusCode));
-                var body = '';
-                res.on('data', function (chunk) {
-                    body += chunk;
-                });
-                res.on('end', function () {
-                    if (res.statusCode !== 201) {
-                        runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, new Error("Bad HTTP response: ".concat(res.statusCode)));
-                        _this.logger.warn("Error report failed: unknown response from server. code=".concat(res.statusCode));
-                        return;
-                    }
-                    var uuid = JSON.parse(body).id;
-                    runAfterNotifyHandlers(merge(notice, {
-                        id: uuid
-                    }), _this.__afterNotifyHandlers);
-                    _this.logger.info("Error report sent \u26A1 https://app.honeybadger.io/notice/".concat(uuid));
-                });
-            });
-            req.on('error', function (err) {
-                _this.logger.error('Error report failed: an unknown error occurred.', "message=".concat(err.message));
-                runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, err);
-            });
-            req.write(data);
-            req.end();
+        return this.__transport
+            .send({
+            method: 'GET',
+            endpoint: endpoint(this.config.endpoint, "v1/check_in/".concat(id)),
+            logger: this.logger,
+        })
+            .then(function () {
+            _this.logger.info('CheckIn sent');
+            return Promise.resolve();
+        })
+            .catch(function (err) {
+            _this.logger.error('CheckIn failed: an unknown error occurred.', "message=".concat(err.message));
         });
     };
     // This method is intended for web frameworks.

package/dist/server/types/browser/transport.d.ts

@@ -0,0 +1,7 @@
+import { Transport, TransportOptions, NoticeTransportPayload } from '../core/types';
+export declare class BrowserTransport implements Transport {
+    send(options: TransportOptions, payload?: NoticeTransportPayload | undefined): Promise<{
+        statusCode: number;
+        body: string;
+    }>;
+}

package/dist/server/types/browser.d.ts

@@ -1,15 +1,12 @@
 import Client from './core/client';
-import { Config } from './core/types';
-interface BrowserConfig extends Config {
-    async: boolean;
-    maxErrors: number;
-}
+import { BrowserConfig } from './core/types';
 declare class Honeybadger extends Client {
     config: BrowserConfig;
     constructor(opts?: Partial<BrowserConfig>);
-    configure(opts?: Partial<BrowserConfig>): Client;
+    configure(opts?: Partial<BrowserConfig>): this;
     resetMaxErrors(): number;
-    factory(opts?: Partial<BrowserConfig>): Honeybadger;
+    factory(opts?: Partial<BrowserConfig>): this;
+    checkIn(_id: string): Promise<void>;
 }
 declare const _default: Honeybadger;
 export default _default;

package/dist/server/types/core/client.d.ts

@@ -1,5 +1,5 @@
-import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable, HoneybadgerStore, BreadcrumbRecord } from './types';
-export default class Client {
+import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable, HoneybadgerStore, BreadcrumbRecord, Transport, NoticeTransportPayload } from './types';
+export default abstract class Client {
     protected __pluginsExecuted: boolean;
     protected __store: HoneybadgerStore<{
         context: Record<string, unknown>;
@@ -7,13 +7,15 @@ export default class Client {
     }>;
     protected __beforeNotifyHandlers: BeforeNotifyHandler[];
     protected __afterNotifyHandlers: AfterNotifyHandler[];
-    protected __getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void;
+    protected __getSourceFileHandler: (path: string) => Promise<string>;
+    protected readonly __transport: Transport;
     config: Config;
     logger: Logger;
-    constructor(opts?: Partial<Config>);
-    factory(_opts?: Partial<Config>): Client;
+    protected constructor(opts: Partial<Config>, transport: Transport);
+    protected abstract factory(opts: Partial<Config>): this;
+    protected abstract checkIn(id: string): Promise<void>;
     getVersion(): string;
-    configure(opts?: Partial<Config>): Client;
+    configure(opts?: Partial<Config>): this;
     beforeNotify(handler: BeforeNotifyHandler): Client;
     afterNotify(handler: AfterNotifyHandler): Client;
     setContext(context: Record<string, unknown>): Client;
@@ -30,7 +32,6 @@ export default class Client {
     protected makeNotice(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Notice | null;
     addBreadcrumb(message: string, opts?: Record<string, unknown>): Client;
     protected __developmentMode(): boolean;
-    protected __send(_notice: Partial<Notice>): void;
-    protected __buildPayload(notice: Notice): Record<string, Record<string, unknown>>;
+    protected __buildPayload(notice: Notice): NoticeTransportPayload;
     protected __constructTags(tags: unknown): Array<string>;
 }

package/dist/server/types/core/store.d.ts

@@ -1,4 +1,4 @@
-import { HoneybadgerStore } from "./types";
+import { HoneybadgerStore } from './types';
 export declare class GlobalStore<T> implements HoneybadgerStore<T> {
     private store;
     constructor(store: T);