Custom Metric Aggregation

In this lesson, you will learn how to shift from raw logging to meaningful data by implementing custom metric aggregation for business-critical events.

While logs are excellent for debugging specific instances, they are expensive and noisy to analyze for high-level trends. "Custom Metric Aggregation" allows you to track application state changes—like total orders processed or active user sessions—in memory, and then export these aggregated totals at defined intervals.

Why Aggregate?

If you log every single order as a structured JSON object, your storage costs will explode and your monitoring tools will struggle to compute "orders per minute" over long timeframes. Instead, we maintain an in-memory counter or a state object and export the snapshot.

Implementation Pattern

The simplest way to implement this is to define an aggregator class that acts as a singleton within your application.

class MetricCollector {
  constructor() {
    this.metrics = {
      totalOrders: 0,
      activeSessions: new Set()
    };
  }

  incrementOrder() {
    this.metrics.totalOrders++;
  }

  trackSession(id) {
    this.metrics.activeSessions.add(id);
  }

  // Export current state to your monitoring system
  getSnapshot() {
    return {
      totalOrders: this.metrics.totalOrders,
      activeSessionsCount: this.metrics.activeSessions.size,
      timestamp: new Date().toISOString()
    };
  }
}

const collector = new MetricCollector();
module.exports = collector;

In your application logic, you simply call collector.incrementOrder() whenever a successful transaction occurs. To expose this to your infrastructure, you can integrate this with your Building an Internal Health Check Endpoint (Lesson 22). When a monitoring agent pings your health check route, your application responds with the current getSnapshot() data rather than just a status code.

By keeping these metrics in memory, you reduce I/O overhead significantly. However, remember that because these are in-memory, they reset on process restart. If high availability of these counts is required across restarts, consider using a high-performance, atomic store like Redis to increment these counters, allowing you to persist your business logic telemetry outside the volatile process lifecycle.

Key Takeaway: Instead of logging every event to reconstruct data later, aggregate your business KPIs in-memory and expose summarized snapshots to reduce logging overhead and improve analysis performance.