Efficient Logging in Node.js with TypeScript: A Guide to Buffered Logging

In high-performance Node.js applications, logging can often become a bottleneck, especially when logging operations are frequent and intensive. Synchronous logging calls, such as console.log, can block the event loop, degrading application performance. This article explores the concept of buffered logging, where log messages are cached and periodically written to a file, reducing the performance impact.

Understanding Logging in Node.js

By default, Node.js provides console.log for logging purposes. While convenient, console.log is synchronous and can block the event loop, leading to performance issues in high-throughput applications. To mitigate this, we can employ a buffered logging strategy.

Buffered Logging Explained

Buffered logging involves accumulating log messages in a buffer and writing them to a log file at regular intervals or when the buffer reaches a certain size. This reduces the number of I/O operations, as multiple log messages are written in a single operation, thus improving overall performance.

Implementing Buffered Logging in TypeScript

Let's implement a buffered logging system in TypeScript, encapsulated in a Logger class.

Step 1: Setting Up the Project

First, create a new Node.js project and install the necessary dependencies.

mkdir buffered-logger
cd buffered-logger
npm init -y
npm install typescript @types/node
npx tsc --init

Step 2: Creating the Logger Class

Create a Logger class in a new file Logger.ts.

import * as fs from 'fs';

class Logger {
    private buffer: string[] = [];
    private interval: NodeJS.Timeout;

    constructor(private logFile: string, private flushInterval: number = 100) {
        this.interval = setInterval(() => this.flush(), flushInterval);

    log(message: string): void {

    private flush(): void {
        if (this.buffer.length > 0) {
            const logLines = this.buffer.join('\n') + '\n';
            fs.appendFile(this.logFile, logLines, (err) => {
                if (err) {
                    console.error('Error writing log file:', err);
            this.buffer = [];

    stop(): void {

Step 3: Using the Logger Class

Create a new file app.ts to demonstrate the usage of the Logger class.

import { Logger } from './Logger';

const logger = new Logger('app.log');

logger.log('This is a log message');
logger.log('This is another log message');

// Ensure to stop the logger on process exit to flush remaining logs
process.on('exit', () => {

// Simulate application workload
setInterval(() => {
    logger.log(`Log message at ${new Date().toISOString()}`);
}, 50);

Step 4: Running the Application

Compile the TypeScript files and run the application.

npx tsc
node app.js

Enhancing the Logger Class

To make the Logger class more robust, consider the following enhancements:

  • Buffer Size Management: Flush the buffer when it reaches a certain size, in addition to periodic flushing.
  • Error Handling: Implement more comprehensive error handling and logging.
  • Configuration Options: Allow configuration of buffer size, flush interval, and other parameters.

Our take

Buffered logging is an effective strategy to minimize the performance impact of logging in high-throughput Node.js applications. By implementing a Logger class in TypeScript that caches log messages and writes them at regular intervals, you can significantly improve the performance and responsiveness of your application. This approach reduces the number of I/O operations, ensures efficient log management, and maintains the integrity of your logging system.

For more advanced logging requirements, consider using dedicated logging libraries like pino, which are designed for high-performance asynchronous logging and offer additional features such as log levels, rotation, and integration with monitoring tools.

By adopting buffered logging practices, you can enhance the scalability and efficiency of your Node.js applications, ensuring they remain performant even under heavy load.

Need consulting?

creative agency for ambitious projects.