Monitoring TypeScript Applications: Tools and Setup |…

Monitoring TypeScript Applications: From Errors to Performance

Monitoring TypeScript applications is a set of practices and tools that ensure system observability in real time. Unlike simple logging, professional monitoring includes collecting metrics, request tracing, error aggregation, and automatic alerting. For TypeScript, running both on the server (Node.js) and in the browser, having a unified observation system is critically important. In this article, we will break down key tools and examples of their integration.

Why Monitor TypeScript Applications?

TypeScript compiles to JavaScript, which imposes specific debugging characteristics. The source code with types turns into dynamic JS, and type errors can only manifest at runtime. Without monitoring, you risk:

Missing TypeError or ReferenceError in production
Not noticing performance degradation (slow requests, memory leaks)
Losing error context (stack trace, user data, environment)

Core Components of a Monitoring System

A modern monitoring stack is built on three pillars: logs, metrics, and traces. For TypeScript applications, we will look at specific libraries:

1. Sentry — The King of Error Tracking

Sentry is a SaaS platform for error and performance monitoring. For TypeScript, official packages @sentry/node and @sentry/react are available. It automatically catches exceptions, collects stack traces, and context.

Installation:

npm install @sentry/node @sentry/tracing

Basic initialization in Node.js:

import * as Sentry from '@sentry/node';import { ProfilingIntegration } from '@sentry/profiling-node';

Sentry.init({  dsn: 'https://examplePublicKey@o0.ingest.sentry.io/0',  integrations: [new ProfilingIntegration()],  tracesSampleRate: 1.0, // trace collection frequency (0-1)  profilesSampleRate: 1.0, // performance profiling});

// Manual call on errorapp.get('/api/users', async (req, res) => {  try {    const users = await getUsers();    res.json(users);  } catch (error) {    Sentry.captureException(error);    res.status(500).send('Internal Server Error');  }});

Advantages:

Automatic linking of errors to releases
Support for source maps for TypeScript
Performance: monitoring slow transactions

2. OpenTelemetry — The Observability Standard

OpenTelemetry (OTel) is an open standard for collecting telemetry. For TypeScript, the @opentelemetry/sdk-node package is used. OTel allows collecting traces and metrics, then sending them to any system (Jaeger, Prometheus, Datadog).

Example integration with Express:

import { NodeSDK } from '@opentelemetry/sdk-node';import { getNodeAutoInstrumentations } from '@opentelemetry/instrumentation-node';

const sdk = new NodeSDK({  instrumentations: [getNodeAutoInstrumentations()],  // exporter can be configured for OTLP or console});

sdk.start();

// All Express logic is automatically tracedimport express from 'express';const app = express();app.get('/data', (req, res) => {  res.json({ status: 'ok' });});

OpenTelemetry automatically instruments popular libraries: Express, MongoDB, Redis, gRPC. This provides a complete picture of request flow through services.