Designing Scalable TypeScript Systems to Handle Distributed Error Logging

When building modern applications, especially those running on multiple servers or microservices, handling errors in a centralized and scalable way is crucial. Distributed error logging helps you collect and analyze errors from different parts of your system in one place. In this beginner-friendly guide, we'll explore how to design scalable TypeScript systems to handle distributed error logging.

### Why Distributed Error Logging? In a distributed system, errors can happen on any server or service. Without a central place to log these errors, debugging becomes difficult. Centralized error logging allows you to: - Detect issues faster - Understand error patterns - Monitor system health - Improve user experience

### Core Concepts for Scalable Logging 1. **Structured Logs**: Use consistent formats (like JSON) for logs so they can be easily parsed and searched. 2. **Centralized Storage**: Send logs to a central store like Elasticsearch, Logstash, or cloud services such as AWS CloudWatch. 3. **Non-blocking Logging**: Ensure logging does not slow down your application. 4. **Error Metadata**: Include useful data like timestamp, service name, and error details.

### Designing a TypeScript Error Logger Let's build a simple reusable error logger in TypeScript that formats errors and sends them to a remote logging service via HTTP. This example demonstrates basic principles you can extend.

interface ErrorLogEntry {
  timestamp: string;
  service: string;
  level: 'error' | 'warn' | 'info';
  message: string;
  stack?: string;
  context?: Record<string, unknown>;
}

class DistributedErrorLogger {
  private serviceName: string;
  private endpoint: string;

  constructor(serviceName: string, endpoint: string) {
    this.serviceName = serviceName;
    this.endpoint = endpoint; // URL of centralized logging API
  }

  async logError(error: Error, context?: Record<string, unknown>) {
    const logEntry: ErrorLogEntry = {
      timestamp: new Date().toISOString(),
      service: this.serviceName,
      level: 'error',
      message: error.message,
      stack: error.stack,
      context,
    };

    try {
      await fetch(this.endpoint, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(logEntry),
      });
    } catch (sendError) {
      // Fallback: log to console if sending fails
      console.error('Failed to send error log:', sendError);
      console.error('Original error:', logEntry);
    }
  }
}

### Using the Logger You can create an instance of this logger in any part of your app or service to report errors:

const logger = new DistributedErrorLogger('auth-service', 'https://logging.example.com/api/logs');

async function authenticateUser() {
  try {
    // Simulate a failure
    throw new Error('Invalid credentials');
  } catch (err) {
    await logger.logError(err, { username: 'john_doe' });
  }
}

### Tips for Scaling - **Batching & Buffering:** Collect multiple logs and send them in batches to reduce network calls. - **Retry Logic:** Reattempt sending logs on failure. - **Logging Levels:** Add support for different log levels like warn, info, and debug to filter logs. - **Monitoring & Alerts:** Integrate with monitoring tools to alert on critical errors automatically. By starting with this simple pattern and gradually adding these features, you can build a strong distributed error logging system in TypeScript.

### Summary Distributed error logging is vital for debugging and monitoring modern applications. Using TypeScript, you can create structured and scalable logging mechanisms to collect and centralize error data from multiple services. Start small by sending JSON error logs to a central endpoint, then enhance your system with batching, retries, and alerting as your system grows.