TypeScript (tsc)

Upload your source maps using tsc and Sentry CLI.

In this guide, you'll learn how to successfully upload source maps for TypeScript using our sentry-cli tool.

This guide assumes the following:

  • sentry-cli version >= 2.17.0
  • Sentry Javascript SDK version >= 7.47.0

This guide is only applicable if you're using tsc to compile your project. If you use another tool (such as webpack) in combination with TypeScript, you'll most likely want to follow that guide instead.

The easiest way to configure uploading source maps with tsc and sentry-cli is by using the Sentry Wizard:

Copied
npx @sentry/wizard@latest -i sourcemaps

The wizard will guide you through the following steps:

  • Logging into Sentry and selecting a project
  • Installing the necessary Sentry packages
  • Configuring your build tool to generate and upload source maps
  • Configuring your CI to upload source maps

If you want to configure source maps upload manually instead, follow the steps below.

First, configure the TypeScript compiler to output source maps:

tsconfig.json
Copied
{
  "compilerOptions": {
    "sourceMap": true,
    "inlineSources": true,

    // Set `sourceRoot` to  "/" to strip the build path prefix from
    // generated source code references. This will improve issue grouping in Sentry.
    "sourceRoot": "/"
  }
}

You can find installation instructions for Sentry CLI here: https://docs.sentry.io/product/cli/installation/

For more info on sentry-cli configuration visit the Sentry CLI configuration docs.

Make sure sentry-cli is configured for your project. For that you can use environment variables:

.env.local
Copied
SENTRY_ORG=example-org
SENTRY_PROJECT=example-project
SENTRY_AUTH_TOKEN=sntrys_YOUR_TOKEN_HERE

Debug IDs are used to match the stack frame of an event with its corresponding minified source and source map file. Visit What are Artifact Bundles if you want to learn more about Artifact Bundles and Debug IDs.

To inject Debug IDs, use the following command:

Copied
sentry-cli sourcemaps inject /path/to/directory

Minified source files should contain at the end a comment named debugId like:

example_minified_file.js
Copied
...
//# debugId=<debug_id>
//# sourceMappingURL=<sourcemap_url>

Source maps should contain a field named debug_id like:

example_source_map.js.map
Copied
{
    ...
    "debug_id":"<debug_id>",
    ...
}

After you've injected Debug IDs into your artifacts, upload them using the following command.

Copied
sentry-cli sourcemaps upload /path/to/directory

Open up Sentry and navigate to Project Settings > Source Maps. If you choose “Artifact Bundles” in the tabbed navigation, you'll see all the artifact bundles that have been successfully uploaded to Sentry.

Provide a release property in your SDK options.

Copied
Sentry.init({
  // This value must be identical to the release name specified during upload
  // with the `sentry-cli`.
  release: "<release_name>",
});

Afterwards, run the sourcemaps upload command with the additional --release option. Please ensure that the value specified for <release_name> is the same value specified in your SDK options.

Copied
sentry-cli sourcemaps upload --release=<release_name> /path/to/directory

Running upload with --release doesn't automatically create a release in Sentry. Either wait until the first event with the new release set in Sentry.init is sent to Sentry, or create a release with the same name in a separate step with the CLI.

In addition to release, you can also add a dist to your uploaded artifacts, to set the distribution identifier for uploaded files. To do so, run the sourcemaps upload command with the additional --dist option.

The distribution identifier is used to distinguish between multiple files of the same name within a single release. dist can be used to disambiguate build or deployment variants.

Copied
sentry-cli sourcemaps upload --release=<release_name> --dist=<dist_name> /path/to/directory

If you're following this guide from your local machine, then you've successfully:

  1. Generated minified source and source map files (artifacts) by running your application's build process
  2. Injected Debug IDs into the artifacts you've just generated
  3. Uploaded those artifacts to Sentry with our upload command

The last step is deploying a new version of your application using the generated artifacts you created in step one. We strongly recommend that you integrate sentry-cli into your CI/CD Pipeline, to ensure each subsequent deploy will automatically inject debug IDs into each artifact and upload them directly to Sentry.

During compilation, if needed, TypeScript will inject some of its runtime dependencies into the output files it produces. It can include things like polyfills for function generators or some APIs not available in all the environments.

However, this makes it impossible to map frames from compiled code to the original sources, as there are no original sources.

We can still make it work, though. To do this, we need to tell the TypeScript compiler not to inject those code snippets and use its own 3rd party package called tslib, which is internally the part of a compiler.

The only things that have to change are inside the TypeScript config file, not your source code.

First, make sure that tslib is listed as the dependency in your package.json file. Once that's done, add two entries in compilerOptions section of your tsconfig.json. "noEmitHelpers": true and "importHelpers": true. That's it. Now, we can correctly map the source maps for all your stack trace frames, including internal TypeScript compiler code snippets.

Help improve this content
Our documentation is open source and available on GitHub. Your contributions are welcome, whether fixing a typo (drat!) or suggesting an update ("yeah, this would be better").