Testing Logging and Telemetry Output

In this lesson, you will learn how to verify that your Node.js application correctly emits structured telemetry and log events to observability platforms without relying on fragile string-matching techniques.

The Problem with Standard Output

When testing logging, developers often try to capture console.log or read from stdout. This is brittle because log formats change, and it ignores the structured data (JSON) that observability tools like ELK, Datadog, or Honeycomb require for indexing. To test this effectively, you must treat your logger as an event emitter or a transport dependency.

Decoupling the Logger

The most robust approach is to inject a mockable logger instance into your service. Instead of checking if a string was printed, you verify that a specific function was called with the expected metadata.

Consider a service that logs a user’s checkout event:

// service.js
export class CheckoutService {
  constructor(logger) { this.logger = logger; }

  process(orderId) {
    // ... business logic
    this.logger.info('order_processed', { orderId, timestamp: Date.now() });
  }
}

// checkout.test.js
it('emits the correct telemetry event upon checkout', () => {
  const mockLogger = { info: jest.fn() };
  const service = new CheckoutService(mockLogger);

  service.process('ORD-123');

  expect(mockLogger.info).toHaveBeenCalledWith('order_processed', expect.objectContaining({
    orderId: 'ORD-123'
  }));
});

Why This Matters

By asserting against the object passed to the logger, you ensure that the contract with your observability platform remains intact. If a developer accidentally removes the orderId field or changes the event name, your tests will fail immediately, even if the application logic itself appears to function correctly.

This approach allows you to validate high-cardinality data—such as trace IDs, user segments, or environment tags—which are crucial for distributed tracing. When testing asynchronous or background tasks, ensure your test runner is configured to await these calls, as telemetry emitters often buffer their output to minimize performance overhead.

Key Takeaway: Never test logs by parsing text; instead, mock your logger and assert that the correct structured metadata object is emitted as an argument.