hardhat
Version:
Hardhat is an extensible developer tool that helps smart contract developers increase productivity by reliably bringing together the tools they want.
94 lines • 3.81 kB
JavaScript
/* This file is inspired by https://github.com/getsentry/sentry-javascript/blob/9.4.0/packages/node/src/sdk/index.ts */
import os from "node:os";
import path from "node:path";
import { createStackParser, functionToStringIntegration, initAndBind, linkedErrorsIntegration, nodeStackLineParser, ServerRuntimeClient, stackParserFromStackParserOptions, } from "@sentry/core";
import debug from "debug";
import { GENERIC_SERVER_NAME } from "./constants.js";
import { nodeContextIntegration } from "./vendor/integrations/context.js";
import { contextLinesIntegration } from "./vendor/integrations/contextlines.js";
import { createGetModuleFromFilename } from "./vendor/utils/module.js";
const log = debug("hardhat:core:sentry:init");
/**
* This function initializes a custom global sentry reporter/client.
*
* There are two reasons why we customize it, instead of using the default one
* provided by @sentry/node:
* - @sentry/node has an astronomical amount of dependencies -- See https://github.com/getsentry/sentry-javascript/discussions/13846
* - We customize the transport to avoid blocking the main Hardhat process
* while reporting errors.
*
* Once you initialize the custom global sentry reporter, you can use the usual
* `captureException` and `captureMessage` functions exposed by @sentry/core.
*
* The reason that this uses the global instance of sentry (by calling
* initAndBind), is that using the client directly doesn't work with the linked
* errors integration.
*
* Calling `init` also has an option to set global unhandled rejection and
* uncaught exception handlers.
*/
export function init(options) {
const client = initAndBind(ServerRuntimeClient, {
dsn: options.dsn,
environment: options.environment,
serverName: GENERIC_SERVER_NAME,
release: options.release,
initialScope: {
contexts: {
os: {
name: os.type(),
build: os.release(),
version: os.version(),
},
device: {
arch: os.arch(),
},
runtime: {
name: path.basename(process.title),
version: process.version,
},
},
},
transport: () => options.transport,
integrations: [
functionToStringIntegration(),
contextLinesIntegration(),
linkedErrorsIntegration(),
nodeContextIntegration(),
],
platform: process.platform,
stackParser: stackParserFromStackParserOptions(createStackParser(nodeStackLineParser(createGetModuleFromFilename()))),
});
setupGlobalUnhandledErrorHandlers(client);
}
function createUnhandledErrorListener(client, isPromiseRejection) {
const description = isPromiseRejection
? "Unhandled promise rejection"
: "Uncaught exception";
async function listener(error) {
log(description, error);
client.captureException(error, {
captureContext: {
level: "fatal",
},
mechanism: {
handled: false,
type: "onuncaughtexception",
},
});
await client.flush(100);
await client.close(100);
console.error();
console.error(`${description}:`);
console.error();
console.error(error);
process.exit(1);
}
return listener;
}
function setupGlobalUnhandledErrorHandlers(client) {
log("Setting up global unhandled error handlers");
process.on("uncaughtException", createUnhandledErrorListener(client, false));
process.on("unhandledRejection", createUnhandledErrorListener(client, true));
}
//# sourceMappingURL=init.js.map