@honeybadger-io/js 6.5.2 → 6.6.0

package/dist/server/checkins-sync-exec.js

@@ -0,0 +1,885 @@
+#!/usr/bin/env node
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var require$$0 = require('os');
+var require$$1 = require('fs');
+var require$$2 = require('util');
+var require$$3 = require('cosmiconfig');
+var require$$0$1 = require('@honeybadger-io/core');
+var require$$1$1 = require('url');
+var require$$3$1 = require('http');
+var require$$4 = require('https');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
+var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
+var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
+var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
+var require$$3__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$3$1);
+var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var checkinsSyncExec = {};
+
+var checkinsSync = {};
+
+var util = {};
+
+var __awaiter$3 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (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());
+    });
+};
+var __generator$3 = (commonjsGlobal && commonjsGlobal.__generator) || function (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 __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(util, "__esModule", { value: true });
+util.readConfigFromFileSystem = util.getSourceFile = util.getStats = util.fatallyLogAndExit = void 0;
+var os_1 = __importDefault(require$$0__default["default"]);
+var fs_1 = __importDefault(require$$1__default["default"]);
+var util_1$1 = require$$2__default["default"];
+var cosmiconfig_1 = require$$3__default["default"];
+var readFile = (0, util_1$1.promisify)(fs_1.default.readFile);
+function fatallyLogAndExit(err) {
+    console.error('[Honeybadger] Exiting process due to uncaught exception');
+    console.error(err.stack || err);
+    process.exit(1);
+}
+util.fatallyLogAndExit = fatallyLogAndExit;
+function getStats() {
+    return __awaiter$3(this, void 0, void 0, function () {
+        var load, stats, fallback, memData, data, results;
+        return __generator$3(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    load = os_1.default.loadavg();
+                    stats = {
+                        load: {
+                            one: load[0],
+                            five: load[1],
+                            fifteen: load[2]
+                        },
+                        mem: {}
+                    };
+                    fallback = function () {
+                        stats.mem = {
+                            free: os_1.default.freemem(),
+                            total: os_1.default.totalmem()
+                        };
+                    };
+                    if (!fs_1.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];
+            }
+        });
+    });
+}
+util.getStats = getStats;
+/**
+ * Get source file if possible, used to build `notice.backtrace.source`
+ *
+ * @param path to source code
+ */
+function getSourceFile(path) {
+    return __awaiter$3(this, void 0, void 0, function () {
+        return __generator$3(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*/];
+            }
+        });
+    });
+}
+util.getSourceFile = getSourceFile;
+function readConfigFromFileSystem$1() {
+    return readConfigForModule('honeybadger');
+}
+util.readConfigFromFileSystem = readConfigFromFileSystem$1;
+function readConfigForModule(moduleName) {
+    var _a;
+    try {
+        var fileExplorer = (0, cosmiconfig_1.cosmiconfigSync)(moduleName);
+        var result = fileExplorer.search();
+        return (_a = result === null || result === void 0 ? void 0 : result.config) !== null && _a !== void 0 ? _a : null;
+    }
+    catch (e) {
+        console.debug("[Honeybadger] Could not read config for module ".concat(moduleName, ": ").concat(e.message));
+        return null;
+    }
+}
+
+var checkinsManager = {};
+
+var client = {};
+
+var checkin = {};
+
+Object.defineProperty(checkin, "__esModule", { value: true });
+checkin.Checkin = void 0;
+var Checkin = /** @class */ (function () {
+    function Checkin(props) {
+        this.id = props.id;
+        this.name = props.name;
+        this.slug = props.slug;
+        this.scheduleType = props.scheduleType;
+        this.reportPeriod = props.reportPeriod;
+        this.gracePeriod = props.gracePeriod;
+        this.cronSchedule = props.cronSchedule;
+        this.cronTimezone = props.cronTimezone;
+        this.projectId = props.projectId;
+        this.deleted = false;
+    }
+    Checkin.prototype.isDeleted = function () {
+        return this.deleted;
+    };
+    Checkin.prototype.markAsDeleted = function () {
+        this.deleted = true;
+    };
+    Checkin.prototype.validate = function () {
+        if (!this.projectId) {
+            throw new Error('projectId is required for each checkin');
+        }
+        if (!this.name) {
+            throw new Error('name is required for each checkin');
+        }
+        if (!this.scheduleType) {
+            throw new Error('scheduleType is required for each checkin');
+        }
+        if (!['simple', 'cron'].includes(this.scheduleType)) {
+            throw new Error("".concat(this.name, " [scheduleType] must be \"simple\" or \"cron\""));
+        }
+        if (this.scheduleType === 'simple' && !this.reportPeriod) {
+            throw new Error("".concat(this.name, " [reportPeriod] is required for simple checkins"));
+        }
+        if (this.scheduleType === 'cron' && !this.cronSchedule) {
+            throw new Error("".concat(this.name, " [cronSchedule] is required for cron checkins"));
+        }
+    };
+    Checkin.prototype.asRequestPayload = function () {
+        var _a, _b, _c;
+        var payload = {
+            name: this.name,
+            schedule_type: this.scheduleType,
+            slug: (_a = this.slug) !== null && _a !== void 0 ? _a : '',
+            grace_period: (_b = this.gracePeriod) !== null && _b !== void 0 ? _b : '' // default is empty string
+        };
+        if (this.scheduleType === 'simple') {
+            payload.report_period = this.reportPeriod;
+        }
+        else {
+            payload.cron_schedule = this.cronSchedule;
+            payload.cron_timezone = (_c = this.cronTimezone) !== null && _c !== void 0 ? _c : ''; // default is empty string
+        }
+        return payload;
+    };
+    /**
+     * Compares two checkins, usually the one from the API and the one from the config file.
+     * If the one in the config file does not match the checkin from the API,
+     * then we issue an update request.
+     */
+    Checkin.prototype.isInSync = function (other) {
+        var _a, _b, _c, _d, _e, _f;
+        return this.name === other.name
+            && this.projectId === other.projectId
+            && this.scheduleType === other.scheduleType
+            && this.reportPeriod === other.reportPeriod
+            && this.cronSchedule === other.cronSchedule
+            && ((_a = this.slug) !== null && _a !== void 0 ? _a : '') === ((_b = other.slug) !== null && _b !== void 0 ? _b : '')
+            && ((_c = this.gracePeriod) !== null && _c !== void 0 ? _c : '') === ((_d = other.gracePeriod) !== null && _d !== void 0 ? _d : '')
+            && ((_e = this.cronTimezone) !== null && _e !== void 0 ? _e : '') === ((_f = other.cronTimezone) !== null && _f !== void 0 ? _f : '');
+    };
+    Checkin.fromResponsePayload = function (projectId, payload) {
+        return new Checkin({
+            projectId: projectId,
+            id: payload.id,
+            name: payload.name,
+            slug: payload.slug,
+            scheduleType: payload.schedule_type,
+            reportPeriod: payload.report_period,
+            gracePeriod: payload.grace_period,
+            cronSchedule: payload.cron_schedule,
+            cronTimezone: payload.cron_timezone,
+        });
+    };
+    return Checkin;
+}());
+checkin.Checkin = Checkin;
+
+var __awaiter$2 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (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());
+    });
+};
+var __generator$2 = (commonjsGlobal && commonjsGlobal.__generator) || function (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 };
+    }
+};
+Object.defineProperty(client, "__esModule", { value: true });
+client.CheckinsClient = void 0;
+var checkin_1$1 = checkin;
+var CheckinsClient = /** @class */ (function () {
+    function CheckinsClient(config, transport) {
+        this.BASE_URL = 'https://app.honeybadger.io';
+        this.transport = transport;
+        this.config = config;
+        this.logger = config.logger;
+        this.cache = {};
+    }
+    CheckinsClient.prototype.listForProject = function (projectId) {
+        return __awaiter$2(this, void 0, void 0, function () {
+            var response, data, checkins;
+            return __generator$2(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.cache[projectId]) {
+                            return [2 /*return*/, this.cache[projectId]];
+                        }
+                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+                            throw new Error('personalAuthToken is required');
+                        }
+                        return [4 /*yield*/, this.transport.send({
+                                method: 'GET',
+                                headers: this.getHeaders(),
+                                endpoint: "".concat(this.BASE_URL, "/v2/projects/").concat(projectId, "/check_ins"),
+                                logger: this.logger,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.statusCode !== 200) {
+                            throw new Error("Failed to fetch checkins for project[".concat(projectId, "]: ").concat(this.getErrorMessage(response.body)));
+                        }
+                        data = JSON.parse(response.body);
+                        checkins = data.results.map(function (checkin) { return checkin_1$1.Checkin.fromResponsePayload(projectId, checkin); });
+                        this.cache[projectId] = checkins;
+                        return [2 /*return*/, checkins];
+                }
+            });
+        });
+    };
+    CheckinsClient.prototype.get = function (projectId, checkinId) {
+        return __awaiter$2(this, void 0, void 0, function () {
+            var response, data, checkin;
+            return __generator$2(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+                            throw new Error('personalAuthToken is required');
+                        }
+                        return [4 /*yield*/, this.transport.send({
+                                method: 'GET',
+                                headers: this.getHeaders(),
+                                endpoint: "".concat(this.BASE_URL, "/v2/projects/").concat(projectId, "/check_ins/").concat(checkinId),
+                                logger: this.logger,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.statusCode !== 200) {
+                            throw new Error("Failed to fetch checkin[".concat(checkinId, "] for project[").concat(projectId, "]: ").concat(this.getErrorMessage(response.body)));
+                        }
+                        data = JSON.parse(response.body);
+                        checkin = checkin_1$1.Checkin.fromResponsePayload(projectId, data);
+                        checkin.projectId = projectId;
+                        return [2 /*return*/, checkin];
+                }
+            });
+        });
+    };
+    CheckinsClient.prototype.create = function (checkin) {
+        return __awaiter$2(this, void 0, void 0, function () {
+            var response, data, result;
+            return __generator$2(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+                            throw new Error('personalAuthToken is required');
+                        }
+                        return [4 /*yield*/, this.transport.send({
+                                method: 'POST',
+                                headers: this.getHeaders(),
+                                endpoint: "".concat(this.BASE_URL, "/v2/projects/").concat(checkin.projectId, "/check_ins"),
+                                logger: this.logger,
+                            }, { check_in: checkin.asRequestPayload() })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.statusCode !== 201) {
+                            throw new Error("Failed to create checkin[".concat(checkin.name, "] for project[").concat(checkin.projectId, "]: ").concat(this.getErrorMessage(response.body)));
+                        }
+                        data = JSON.parse(response.body);
+                        result = checkin_1$1.Checkin.fromResponsePayload(checkin.projectId, data);
+                        result.projectId = checkin.projectId;
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    CheckinsClient.prototype.update = function (checkin) {
+        return __awaiter$2(this, void 0, void 0, function () {
+            var response;
+            return __generator$2(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+                            throw new Error('personalAuthToken is required');
+                        }
+                        return [4 /*yield*/, this.transport.send({
+                                method: 'PUT',
+                                headers: this.getHeaders(),
+                                endpoint: "".concat(this.BASE_URL, "/v2/projects/").concat(checkin.projectId, "/check_ins/").concat(checkin.id),
+                                logger: this.logger,
+                            }, { check_in: checkin.asRequestPayload() })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.statusCode !== 204) {
+                            throw new Error("Failed to update checkin[".concat(checkin.name, "] for project[").concat(checkin.projectId, "]: ").concat(this.getErrorMessage(response.body)));
+                        }
+                        return [2 /*return*/, checkin];
+                }
+            });
+        });
+    };
+    CheckinsClient.prototype.remove = function (checkin) {
+        return __awaiter$2(this, void 0, void 0, function () {
+            var response;
+            return __generator$2(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+                            throw new Error('personalAuthToken is required');
+                        }
+                        return [4 /*yield*/, this.transport.send({
+                                method: 'DELETE',
+                                headers: this.getHeaders(),
+                                endpoint: "".concat(this.BASE_URL, "/v2/projects/").concat(checkin.projectId, "/check_ins/").concat(checkin.id),
+                                logger: this.logger,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        if (response.statusCode !== 204) {
+                            throw new Error("Failed to remove checkin[".concat(checkin.name, "] for project[").concat(checkin.projectId, "]: ").concat(this.getErrorMessage(response.body)));
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CheckinsClient.prototype.getHeaders = function () {
+        return {
+            'Authorization': "Basic ".concat(Buffer.from("".concat(this.config.personalAuthToken, ":")).toString('base64')),
+            'Content-Type': 'application/json'
+        };
+    };
+    CheckinsClient.prototype.getErrorMessage = function (responseBody) {
+        var _a;
+        if (!responseBody) {
+            return '';
+        }
+        try {
+            var jsonBody = JSON.parse(responseBody);
+            return (_a = jsonBody.errors) !== null && _a !== void 0 ? _a : '';
+        }
+        catch (e) {
+            return responseBody;
+        }
+    };
+    return CheckinsClient;
+}());
+client.CheckinsClient = CheckinsClient;
+
+var transport = {};
+
+var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(transport, "__esModule", { value: true });
+transport.ServerTransport = void 0;
+var core_1$1 = require$$0__default$1["default"];
+var url_1 = require$$1__default$1["default"];
+var util_1 = util;
+var http = __importStar(require$$3__default$1["default"]);
+var https = __importStar(require$$4__default["default"]);
+var sanitize = core_1$1.Util.sanitize;
+var ServerTransport = /** @class */ (function () {
+    function ServerTransport(headers) {
+        if (headers === void 0) { headers = {}; }
+        this.headers = {};
+        this.headers = headers;
+    }
+    ServerTransport.prototype.defaultHeaders = function () {
+        return this.headers;
+    };
+    ServerTransport.prototype.send = function (options, payload) {
+        var _this = this;
+        var _a = new url_1.URL(options.endpoint), protocol = _a.protocol, hostname = _a.hostname, pathname = _a.pathname;
+        var transport = (protocol === 'http:' ? http : https);
+        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 () {
+                //
+                // We use a httpOptions object to limit issues with libraries that may patch Node.js
+                // See https://github.com/honeybadger-io/honeybadger-js/issues/825#issuecomment-1193113433
+                var httpOptions = {
+                    method: options.method,
+                    headers: __assign(__assign({}, _this.defaultHeaders()), options.headers),
+                    path: pathname,
+                    protocol: protocol,
+                    hostname: hostname,
+                };
+                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(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 (0, util_1.getStats)()
+            .then(function (stats) {
+            payload.server.stats = stats;
+        });
+    };
+    return ServerTransport;
+}());
+transport.ServerTransport = ServerTransport;
+
+var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (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());
+    });
+};
+var __generator$1 = (commonjsGlobal && commonjsGlobal.__generator) || function (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 __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(checkinsManager, "__esModule", { value: true });
+checkinsManager.CheckinsManager = void 0;
+var core_1 = require$$0__default$1["default"];
+var client_1 = client;
+var transport_1 = transport;
+var checkin_1 = checkin;
+var CheckinsManager$1 = /** @class */ (function () {
+    function CheckinsManager(config, client) {
+        var _a, _b, _c, _d;
+        this.config = {
+            debug: (_a = config.debug) !== null && _a !== void 0 ? _a : false,
+            personalAuthToken: (_b = config.personalAuthToken) !== null && _b !== void 0 ? _b : undefined,
+            checkins: (_c = config.checkins) !== null && _c !== void 0 ? _c : [],
+            logger: (_d = config.logger) !== null && _d !== void 0 ? _d : console,
+        };
+        var transport = new transport_1.ServerTransport();
+        this.logger = core_1.Util.logger(this);
+        this.client = client !== null && client !== void 0 ? client : new client_1.CheckinsClient({
+            personalAuthToken: config.personalAuthToken,
+            logger: this.logger
+        }, transport);
+    }
+    CheckinsManager.prototype.sync = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var localCheckins, createdOrUpdated, removed;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // check if personal auth token is set
+                        if (!this.config.personalAuthToken || this.config.personalAuthToken === '') {
+                            throw new Error('personalAuthToken is required');
+                        }
+                        localCheckins = this.getLocalCheckins();
+                        return [4 /*yield*/, this.createOrUpdate(localCheckins)];
+                    case 1:
+                        createdOrUpdated = _a.sent();
+                        return [4 /*yield*/, this.remove(localCheckins)];
+                    case 2:
+                        removed = _a.sent();
+                        return [2 /*return*/, __spreadArray(__spreadArray([], createdOrUpdated, true), removed, true)];
+                }
+            });
+        });
+    };
+    CheckinsManager.prototype.getLocalCheckins = function () {
+        // create checkins from configuration and validate them
+        var localCheckins = this.config.checkins.map(function (dto) {
+            var checkin = new checkin_1.Checkin(dto);
+            checkin.validate();
+            return checkin;
+        });
+        // validate that we have unique checkin names
+        // throw error if there are checkins with the same name and project id
+        var checkinNames = localCheckins.map(function (checkin) { return "".concat(checkin.projectId, "_").concat(checkin.name); });
+        var uniqueCheckinNames = new Set(checkinNames);
+        if (checkinNames.length !== uniqueCheckinNames.size) {
+            throw new Error('check-in names must be unique per project');
+        }
+        return localCheckins;
+    };
+    CheckinsManager.prototype.createOrUpdate = function (localCheckins) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var results, _loop_1, this_1, _i, localCheckins_1, localCheckin;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        results = [];
+                        _loop_1 = function (localCheckin) {
+                            var projectCheckins, remoteCheckin, _b, _c, _d, _e;
+                            return __generator$1(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0: return [4 /*yield*/, this_1.client.listForProject(localCheckin.projectId)];
+                                    case 1:
+                                        projectCheckins = _f.sent();
+                                        remoteCheckin = projectCheckins.find(function (checkin) {
+                                            return checkin.name === localCheckin.name;
+                                        });
+                                        if (!!remoteCheckin) return [3 /*break*/, 3];
+                                        _c = (_b = results).push;
+                                        return [4 /*yield*/, this_1.client.create(localCheckin)];
+                                    case 2:
+                                        _c.apply(_b, [_f.sent()]);
+                                        return [3 /*break*/, 6];
+                                    case 3:
+                                        if (!!localCheckin.isInSync(remoteCheckin)) return [3 /*break*/, 5];
+                                        localCheckin.id = remoteCheckin.id;
+                                        _e = (_d = results).push;
+                                        return [4 /*yield*/, this_1.client.update(localCheckin)];
+                                    case 4:
+                                        _e.apply(_d, [_f.sent()]);
+                                        return [3 /*break*/, 6];
+                                    case 5:
+                                        // no change - still need to add to results
+                                        results.push(remoteCheckin);
+                                        _f.label = 6;
+                                    case 6: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _i = 0, localCheckins_1 = localCheckins;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < localCheckins_1.length)) return [3 /*break*/, 4];
+                        localCheckin = localCheckins_1[_i];
+                        return [5 /*yield**/, _loop_1(localCheckin)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, results];
+                }
+            });
+        });
+    };
+    CheckinsManager.prototype.remove = function (localCheckins) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var projectIds, remoteCheckinsPerProject, allRemoteCheckins, checkinsToRemove;
+            var _this = this;
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        projectIds = Array.from(new Set(localCheckins.map(function (checkin) { return checkin.projectId; })));
+                        return [4 /*yield*/, Promise.all(projectIds.map(function (projectId) {
+                                return _this.client.listForProject(projectId);
+                            }))];
+                    case 1:
+                        remoteCheckinsPerProject = _a.sent();
+                        allRemoteCheckins = remoteCheckinsPerProject.flat();
+                        checkinsToRemove = allRemoteCheckins.filter(function (remoteCheckin) {
+                            return !localCheckins.find(function (localCheckin) {
+                                return localCheckin.name === remoteCheckin.name;
+                            });
+                        });
+                        return [2 /*return*/, Promise.all(checkinsToRemove.map(function (checkin) { return __awaiter$1(_this, void 0, void 0, function () {
+                                return __generator$1(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.client.remove(checkin)];
+                                        case 1:
+                                            _a.sent();
+                                            checkin.markAsDeleted();
+                                            return [2 /*return*/, checkin];
+                                    }
+                                });
+                            }); }))];
+                }
+            });
+        });
+    };
+    return CheckinsManager;
+}());
+checkinsManager.CheckinsManager = CheckinsManager$1;
+
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (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());
+    });
+};
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (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 };
+    }
+};
+Object.defineProperty(checkinsSync, "__esModule", { value: true });
+checkinsSync.syncCheckins = void 0;
+var readConfigFromFileSystem = util.readConfigFromFileSystem;
+var CheckinsManager = checkinsManager.CheckinsManager;
+function syncCheckins$1() {
+    return __awaiter(this, void 0, void 0, function () {
+        var config, checkinsManager, checkins, table;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = readConfigFromFileSystem();
+                    if (!config) {
+                        throw new Error('Could not find a Honeybadger configuration file.');
+                    }
+                    checkinsManager = new CheckinsManager(config);
+                    return [4 /*yield*/, checkinsManager.sync()];
+                case 1:
+                    checkins = _a.sent();
+                    if (!checkins.length) {
+                        console.log('No check-ins found to synchronize with Honeybadger.');
+                        return [2 /*return*/];
+                    }
+                    table = checkins.map(function (c) {
+                        return {
+                            'Id': c.id,
+                            'Name': c.name,
+                            'Slug': c.slug,
+                            'Schedule Type': c.scheduleType,
+                            'Report Period': c.reportPeriod,
+                            'Cron Schedule': c.cronSchedule,
+                            'Cron Timezone': c.cronTimezone,
+                            'Grace Period': c.gracePeriod,
+                            'Status': c.isDeleted() ? '❌ Removed' : '✅ Synchronized'
+                        };
+                    });
+                    console.log('Check-ins were synchronized with Honeybadger.');
+                    console.table(table);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+checkinsSync.syncCheckins = syncCheckins$1;
+
+var syncCheckins = checkinsSync.syncCheckins;
+syncCheckins().catch(function (err) {
+    console.error(err);
+    process.exit(1);
+});
+
+exports["default"] = checkinsSyncExec;
+//# sourceMappingURL=checkins-sync-exec.js.map