Track Angular Components

Sentry's Angular SDK offers a component-tracking feature to monitor the performance of your Angular components. Enabling this feature starts spans that show the initialization and update cycles of your Angular components. This allows you to drill down into how your components are behaving so you can identify slow initializations or frequent updates, which may be impacting your app's performance.

To track your components as part of your transactions, use any (or a combination) of the following options.

Using the trace Directive

Our TraceDirective tracks the duration between the OnInit and AfterViewInit lifecycle hooks in your component template. It adds spans called ui.angular.init to the currently active transaction that allows you to track specific individual instances of your components. To track all instances, use TraceClass.

For both standalone components and NGModule-based app configs, register the TraceModule in the imports array of the standalone component or module that you want to use it in:

import { Component } from "@angular/core";
import { RouterOutlet } from "@angular/router";
import * as Sentry from "@sentry/angular";

@Component({
  selector: "app-root",
  standalone: true,
  imports: [Sentry.TraceModule],
  // ...
})
export class AppComponent {}

Then, in your component's template, add the trace directive to all components you want to track. Remember to give the trace attribute a name, which will be shown in the span's description:

<app-header trace="header"></app-header>
<articles-list trace="articles-list"></articles-list>
<app-footer trace="footer"></app-footer>

Using TraceClass

The TraceClass decorator tracks the duration between the OnInit and AfterViewInit lifecycle hooks in components. It adds spans called ui.angular.init to the currently active transaction. In contrast to the trace directive, TraceClassDecorator tracks all instances of the component(s) you add it to, creating spans for each component instance.

Just add TraceClass decorator with a component name to the components you want to track:

import { Component } from "@angular/core";
import * as Sentry from "@sentry/angular";

@Component({
  selector: "app-header",
  templateUrl: "./header.component.html",
})
@Sentry.TraceClass({ name: "Header" })
export class HeaderComponent {
  // ...
}

Note: Due to code minification in production builds, you need to pass a name property to the TraceClass decorator. Otherwise, spans will refer to the component as <unnamed>.

Using TraceMethod

The TraceMethod decorator tracks specific component lifecycle hooks as point-in-time spans. The added spans are called ui.angular.[methodname] (like, ui.angular.ngOnChanges). For example, you can use this decorator to track how often component changes are detected:

import { Component, OnInit } from "@angular/core";
import * as Sentry from "@sentry/angular";

@Component({
  selector: "app-login",
  templateUrl: "./login.component.html",
})
export class LoginComponent implements OnChanges {
  @Sentry.TraceMethod({ name: "Login.ngOnChanges" })
  ngOnChanges(changes: SimpleChanges) {
    // ...
  }
}

Note: Due to code minification in production builds, you need to pass a name property to the TraceMethod decorator. Otherwise, created spans will refer to the component as <unnamed>.

Advanced Usage

You can combine our component tracking utilities and track the bootstrapping duration of your app.

Combining Component Tracking Utilities

To get the best insights into your components' performance, you can combine TraceDirective, TraceClassDecorator, and TraceMethodDecorator. This allows you to track component initialization durations as well as arbitrary lifecycle events, such as change and destroy events:

import { Component, OnInit } from "@angular/core";
import * as Sentry from "@sentry/angular";

@Component({
  selector: "app-user-card",
  templateUrl: "./user-card.component.html",
})
@Sentry.TraceClass()
export class UserCardComponent implements OnChanges, OnDestroy {
  @Sentry.TraceMethod()
  ngOnChanges(changes: SimpleChanges) {}

  @Sentry.TraceMethod()
  ngOnDestroy() {}
}

Use the trace directive if you only want to track components in certain instances or locations:

<div>
  <app-icon trace="user-icon">user</app-icon>
  <label>{{ user.name }}</label>
  <!--...-->
  <app-button trace="save-user">Save</app-button>
</div>

Track Angular Bootstrapping

You can add your own custom spans using startSpan(). For example, you can track the duration of the Angular bootstrapping process to find out how long your app takes to bootstrap on your users' devices:

import { enableProdMode } from "@angular/core";
import { platformBrowserDynamic } from "@angular/platform-browser-dynamic";
import * as Sentry from "@sentry/angular";

import { AppModule } from "./app/app.module";

// ...

Sentry.startSpan(
  {
    name: "bootstrap-angular-application",
    op: "ui.angular.bootstrap",
  },
  async () => {
    await platformBrowserDynamic()
      .bootstrapModule(AppModule)
      .catch((err) => console.error(err));
  },
);

Learn more about custom instrumentation.