Observability Practices with Sentry: Tracking

XIMENA ANDREA ORTIZ FERNANDEZ — Thu, 03 Jul 2025 05:39:11 +0000

Ximena Andrea Ortiz Fernandez

Abstract

Observability is essential in modern software systems, enabling teams to detect and resolve failures rapidly.

This article demonstrates how to apply observability best practices using Sentry in a Node.js payment processing service.

We illustrate how to track unhandled exceptions, monitor performance, and troubleshoot issues using real-time insights from Sentry.

Readers will learn how integrating Sentry leads to faster debugging, improved stability, and better user experience.

1. What is Observability?

Observability refers to the ability to infer the internal state of a system based on its external outputs. It involves collecting and analyzing:

Logs – Event records of what happened in the system
Metrics – Numerical data over time
Traces – Execution paths of requests across services

Without observability, failures in production systems may go undetected, or worse — remain unresolved due to lack of actionable insights.

2. Why Use Sentry?

Sentry is an observability tool focused on real-time error tracking and performance monitoring. It integrates easily with various programming languages and frameworks. Its benefits include:

Captures uncaught exceptions and rejected promises
Visualizes stack traces with source code context
Tracks user sessions, releases, and error frequency
Provides performance metrics like response times and bottlenecks

3. Real-World Scenario: Payment Service Failure

Let's build a real-world payment microservice with Sentry observability using Express.js and a modular file structure.

📦 Packages

We will use the following Node.js packages:

express – For building the REST API.
@sentry/node – Sentry SDK for Node.js error tracking.

Install all required packages:

npm install express @sentry/node

📁 Project Structure

payment-service/
├── CreditCard.js
├── PaymentService.js
├── Sentry.js
└── server.js

Step 1: Domain Model – `CreditCard.js`

class CreditCard {
  constructor(number, expiry, cvv) {
    this.number = number;
    this.expiry = expiry;
    this.cvv = cvv;
  }

  isValid() {
    return this.number && this.expiry && this.cvv;
  }

  isTestFailure() {
    return this.number === '1234-ERROR';
  }
}

module.exports = CreditCard;

Step 2: Business Logic – `PaymentService.js`

class PaymentService {
  process(card, amount) {
    if (!card.isValid()) {
      throw new Error("Invalid credit card information.");
    }

    if (card.isTestFailure()) {
      throw new Error("Payment gateway timeout (simulated).");
    }

    return {
      status: "success",
      amountProcessed: amount
    };
  }
}

module.exports = PaymentService;

Step 3: Sentry Integration – `Sentry.js`

const Sentry = require('@sentry/node');

Sentry.init({
  dsn: 'YOUR_SENTRY_DSN_HERE',
  tracesSampleRate: 1.0,
  sendDefaultPii: true
});

module.exports = Sentry;

Step 4: API Entry Point – `server.js`

require('./Sentry.js');

const express = require('express');
const Sentry = require('@sentry/node');
const CreditCard = require('./CreditCard');
const PaymentService = require('./PaymentService');

const app = express();
app.use(express.json());

const service = new PaymentService();

app.post('/pay', (req, res, next) => {
  const { number, expiry, cvv, amount } = req.body;
  const card = new CreditCard(number, expiry, cvv);

  try {
    const result = service.process(card, amount);
    res.json(result);
  } catch (err) {
    Sentry.captureException(err);
    res.status(500).json({ error: err.message });
  }
});

app.listen(3000, () => {
  console.log('✅ Payment service running on http://localhost:3000');
});

Step 5: Triggering an Error

To simulate a failed transaction and confirm that Sentry logs the error, use:

curl -X POST http://localhost:3000/pay \
  -H "Content-Type: application/json" \
  -d '{"number":"1234-ERROR","expiry":"12/26","cvv":"123","amount":100}'

Step 6: View in Sentry Dashboard

Log into your Sentry project to view:

Real-time error alerts
Stack traces with line numbers
HTTP request payloads
User impact statistics

4. How Sentry Helps Debugging

When a user attempts to pay with the test card 1234-ERROR, the app throws a custom error. Sentry immediately captures:

Error message: Payment gateway timeout
Stack trace: Shows exact line of failure
Request data: Includes card number and amount
User context: If set, correlates issues to users

Sentry also tracks how often this error occurs and whether it was introduced by a specific release.

5. Conclusion

📂 GitHub Repository: ximena-ortiz/ObservabilityWithSentry

Observability is a fundamental practice for reliable software systems. By integrating Sentry into your application, you can:

Catch errors before users report them
Understand the context of each failure
Monitor performance trends and anomalies
Improve developer velocity and user trust

In production systems where uptime and user satisfaction matter, observability is not optional — it's essential.

DEV Community: XIMENA ANDREA ORTIZ FERNANDEZ