@sentry/nextjs
Version:
Official Sentry SDK for Next.js
232 lines (228 loc) • 10.6 kB
JavaScript
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const diagnosticsChannelInjection = require('../diagnosticsChannelInjection.js');
const buildLogger = require('../buildLogger.js');
const handleRunAfterProductionCompile = require('../handleRunAfterProductionCompile.js');
const constructTurbopackConfig = require('../turbopack/constructTurbopackConfig.js');
const util = require('../util.js');
const webpack = require('../webpack.js');
const constants = require('./constants.js');
const UNSUPPORTED_TURBOPACK_WARNING_SHOWN = "__SENTRY_UNSUPPORTED_TURBOPACK_WARNING_SHOWN__";
function getBundlerInfo(nextJsVersion) {
const activeBundler = util.detectActiveBundler();
const isTurbopack = activeBundler === "turbopack";
const isWebpack = activeBundler === "webpack";
const isTurbopackSupported = util.supportsProductionCompileHook(nextJsVersion ?? "");
return { isTurbopack, isWebpack, isTurbopackSupported };
}
function maybeWarnAboutUnsupportedTurbopack(nextJsVersion, bundlerInfo, silent) {
if (!bundlerInfo.isTurbopackSupported && bundlerInfo.isTurbopack && !silent && process.env[UNSUPPORTED_TURBOPACK_WARNING_SHOWN] !== "1") {
process.env[UNSUPPORTED_TURBOPACK_WARNING_SHOWN] = "1";
buildLogger.getBuildLogger(silent).warn(
`[@sentry/nextjs] WARNING: You are using the Sentry SDK with Turbopack. The Sentry SDK is compatible with Turbopack on Next.js version 15.4.1 or later. You are currently on ${nextJsVersion}. Please upgrade to a newer Next.js version to use the Sentry SDK with Turbopack.`
);
}
}
function maybeWarnAboutTurbopackModuleMetadata(userSentryOptions, bundlerInfo) {
if (bundlerInfo.isTurbopack && userSentryOptions.moduleMetadata) {
buildLogger.getBuildLogger(userSentryOptions.silent).warn(
"[@sentry/nextjs] WARNING: `moduleMetadata` is currently only applied on webpack builds and has no effect on Turbopack builds. Use `applicationKey` if you need `thirdPartyErrorFilterIntegration` support, which works on both bundlers."
);
}
}
function maybeWarnAboutUnsupportedRunAfterProductionCompileHook(nextJsVersion, userSentryOptions, bundlerInfo) {
if (userSentryOptions.useRunAfterProductionCompileHook && !util.supportsProductionCompileHook(nextJsVersion ?? "") && bundlerInfo.isWebpack) {
buildLogger.getBuildLogger(userSentryOptions.silent).warn(
"[@sentry/nextjs] The configured `useRunAfterProductionCompileHook` option is not compatible with your current Next.js version. This option is only supported on Next.js version 15.4.1 or later. Will not run source map and release management logic."
);
}
}
function maybeConstructTurbopackConfig(incomingUserNextConfigObject, userSentryOptions, routeManifest, nextJsVersion, bundlerInfo, vercelCronsConfigResult) {
if (!bundlerInfo.isTurbopack) {
return void 0;
}
const vercelCronsConfig = vercelCronsConfigResult.strategy === "spans" ? vercelCronsConfigResult.config : void 0;
return constructTurbopackConfig.constructTurbopackConfig({
userNextConfig: incomingUserNextConfigObject,
userSentryOptions,
routeManifest,
nextJsVersion,
vercelCronsConfig
});
}
function resolveBuildTimeInstrumentationOption(userSentryOptions, bundlerInfo, nextJsVersion) {
if (userSentryOptions.buildTimeInstrumentation === false) {
return false;
}
if (bundlerInfo.isTurbopack) {
return !!nextJsVersion && util.supportsTurbopackRuleCondition(nextJsVersion);
}
return !userSentryOptions.webpack?.disableSentryConfig;
}
function resolveUseRunAfterProductionCompileHookOption(userSentryOptions, bundlerInfo) {
return userSentryOptions.useRunAfterProductionCompileHook ?? (bundlerInfo.isTurbopack ? true : false);
}
function maybeSetUpRunAfterProductionCompileHook({
incomingUserNextConfigObject,
userSentryOptions,
releaseName,
nextJsVersion,
bundlerInfo,
turboPackConfig,
shouldUseRunAfterProductionCompileHook
}) {
if (!shouldUseRunAfterProductionCompileHook) {
return;
}
if (!util.supportsProductionCompileHook(nextJsVersion ?? "")) {
return;
}
if (incomingUserNextConfigObject?.compiler?.runAfterProductionCompile === void 0) {
incomingUserNextConfigObject.compiler ?? (incomingUserNextConfigObject.compiler = {});
incomingUserNextConfigObject.compiler.runAfterProductionCompile = async ({ distDir }) => {
await handleRunAfterProductionCompile.handleRunAfterProductionCompile(
{
releaseName,
distDir,
buildTool: bundlerInfo.isTurbopack ? "turbopack" : "webpack",
usesNativeDebugIds: bundlerInfo.isTurbopack ? turboPackConfig?.debugIds : void 0,
sriEnabled: !!incomingUserNextConfigObject.experimental?.sri
},
userSentryOptions
);
};
return;
}
if (typeof incomingUserNextConfigObject.compiler.runAfterProductionCompile === "function") {
incomingUserNextConfigObject.compiler.runAfterProductionCompile = new Proxy(
incomingUserNextConfigObject.compiler.runAfterProductionCompile,
{
async apply(target, thisArg, argArray) {
const { distDir } = argArray[0] ?? { distDir: ".next" };
await target.apply(thisArg, argArray);
await handleRunAfterProductionCompile.handleRunAfterProductionCompile(
{
releaseName,
distDir,
buildTool: bundlerInfo.isTurbopack ? "turbopack" : "webpack",
usesNativeDebugIds: bundlerInfo.isTurbopack ? turboPackConfig?.debugIds : void 0,
sriEnabled: !!incomingUserNextConfigObject.experimental?.sri
},
userSentryOptions
);
}
}
);
return;
}
buildLogger.getBuildLogger(userSentryOptions.silent).warn(
"[@sentry/nextjs] The configured `compiler.runAfterProductionCompile` option is not a function. Will not run source map and release management logic."
);
}
function maybeEnableTurbopackSourcemaps(incomingUserNextConfigObject, userSentryOptions, bundlerInfo) {
if (!bundlerInfo.isTurbopackSupported || !bundlerInfo.isTurbopack || userSentryOptions.sourcemaps?.disable) {
return;
}
if (incomingUserNextConfigObject.productionBrowserSourceMaps !== void 0) {
return;
}
const logger = buildLogger.getBuildLogger(userSentryOptions.silent);
if (userSentryOptions.debug) {
logger.log("[@sentry/nextjs] Automatically enabling browser source map generation for turbopack build.");
}
incomingUserNextConfigObject.productionBrowserSourceMaps = true;
if (userSentryOptions.sourcemaps?.deleteSourcemapsAfterUpload !== void 0) {
return;
}
if (userSentryOptions.debug) {
logger.warn(
"[@sentry/nextjs] Source maps will be automatically deleted after being uploaded to Sentry. If you want to keep the source maps, set the `sourcemaps.deleteSourcemapsAfterUpload` option to false in `withSentryConfig()`. If you do not want to generate and upload sourcemaps at all, set the `sourcemaps.disable` option to true."
);
}
userSentryOptions.sourcemaps = {
...userSentryOptions.sourcemaps,
deleteSourcemapsAfterUpload: true
};
}
function getServerExternalPackagesPatch(incomingUserNextConfigObject, nextMajor, buildTimeInstrumentation = false) {
const mergeExternals = (userProvided) => {
const defaults = buildTimeInstrumentation ? diagnosticsChannelInjection.filterInstrumentedExternals(constants.DEFAULT_SERVER_EXTERNAL_PACKAGES, diagnosticsChannelInjection.BUNDLE_SAFE_INSTRUMENTED_PACKAGES) : constants.DEFAULT_SERVER_EXTERNAL_PACKAGES;
return [
...userProvided || [],
...defaults,
...buildTimeInstrumentation ? diagnosticsChannelInjection.ORCHESTRION_RUNTIME_EXTERNAL_PACKAGES : []
];
};
if (nextMajor && nextMajor >= 15) {
return { serverExternalPackages: mergeExternals(incomingUserNextConfigObject.serverExternalPackages) };
}
return {
experimental: {
...incomingUserNextConfigObject.experimental,
serverComponentsExternalPackages: mergeExternals(
incomingUserNextConfigObject.experimental?.serverComponentsExternalPackages
)
}
};
}
function getWebpackPatch({
incomingUserNextConfigObject,
userSentryOptions,
releaseName,
routeManifest,
nextJsVersion,
shouldUseRunAfterProductionCompileHook,
bundlerInfo,
vercelCronsConfigResult
}) {
if (!bundlerInfo.isWebpack || userSentryOptions.webpack?.disableSentryConfig) {
return {};
}
return {
webpack: webpack.constructWebpackConfigFunction({
userNextConfig: incomingUserNextConfigObject,
userSentryOptions,
releaseName,
routeManifest,
nextJsVersion,
useRunAfterProductionCompileHook: shouldUseRunAfterProductionCompileHook,
vercelCronsConfigResult
})
};
}
function maybeSetTurbopackTreeshakeDefines(incomingUserNextConfigObject, userSentryOptions, bundlerInfo) {
if (!bundlerInfo.isTurbopackSupported || !bundlerInfo.isTurbopack) {
return;
}
const defines = webpack.getTreeshakeDefines(userSentryOptions);
if (Object.keys(defines).length === 0) {
return;
}
incomingUserNextConfigObject.compiler = {
...incomingUserNextConfigObject.compiler,
define: {
// Must stay booleans: Turbopack injects string values as string literals, so `'false'` would be truthy.
...defines,
...incomingUserNextConfigObject.compiler?.define
}
};
}
function getTurbopackPatch(bundlerInfo, turboPackConfig) {
if (!bundlerInfo.isTurbopackSupported || !bundlerInfo.isTurbopack) {
return {};
}
return { turbopack: turboPackConfig };
}
exports.getBundlerInfo = getBundlerInfo;
exports.getServerExternalPackagesPatch = getServerExternalPackagesPatch;
exports.getTurbopackPatch = getTurbopackPatch;
exports.getWebpackPatch = getWebpackPatch;
exports.maybeConstructTurbopackConfig = maybeConstructTurbopackConfig;
exports.maybeEnableTurbopackSourcemaps = maybeEnableTurbopackSourcemaps;
exports.maybeSetTurbopackTreeshakeDefines = maybeSetTurbopackTreeshakeDefines;
exports.maybeSetUpRunAfterProductionCompileHook = maybeSetUpRunAfterProductionCompileHook;
exports.maybeWarnAboutTurbopackModuleMetadata = maybeWarnAboutTurbopackModuleMetadata;
exports.maybeWarnAboutUnsupportedRunAfterProductionCompileHook = maybeWarnAboutUnsupportedRunAfterProductionCompileHook;
exports.maybeWarnAboutUnsupportedTurbopack = maybeWarnAboutUnsupportedTurbopack;
exports.resolveBuildTimeInstrumentationOption = resolveBuildTimeInstrumentationOption;
exports.resolveUseRunAfterProductionCompileHookOption = resolveUseRunAfterProductionCompileHookOption;
//# sourceMappingURL=getFinalConfigObjectBundlerUtils.js.map