Logging is a crucial part of software development, whether it’s for debugging, monitoring, or tracking issues in production. Proper log management allows you to trace events in your code, analyze problems, and resolve them efficiently. This article compares how to implement logging in JavaScript (Node.js) and Go, with practical examples and best practices for production-ready applications.

1. Logging in JavaScript (Node.js)

JavaScript provides the built-in console object for basic logging. However, for production applications, using libraries like Winston or Pino is recommended for professional log management.

Basic Logging with Console:

console.log("Informational message");
console.warn("Warning message");
console.error("Error message");

Logging with Winston:

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
      winston.format.timestamp(),
      winston.format.json()
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'app.log' })
  ]
});

logger.info('Server started');
logger.warn('Low disk space');
logger.error('Database connection failed');

Advantages of JavaScript Logging
✔️ Easy to use with a large ecosystem
✔️ Supports log levels, timestamps, and file output
✔️ Can integrate with monitoring tools like Loggly or Datadog

Limitations
⚠️ console.log in production lacks level control
⚠️ Requires additional libraries for production-grade logging

2. Logging in Go

Go has a built-in log package for basic logging and libraries like Logrus or Zap for structured, production-ready logging.

Basic Logging with log:

package main

import (
    "log"
)

func main() {
    log.Println("Informational message")
    log.Println("Warning message")
    log.Println("Error message")
}

Logging with Logrus:

package main

import (
    log "github.com/sirupsen/logrus"
)

func main() {
    log.SetFormatter(&log.JSONFormatter{})
    log.SetLevel(log.InfoLevel)

    log.Info("Server started")
    log.Warn("Low disk space")
    log.Error("Database connection failed")
}

Advantages of Go Logging
✔️ Type-safe with compile-time error checking
✔️ Supports structured logging (JSON)
✔️ Supports log levels, file output, and integration with monitoring

Limitations
⚠️ Syntax is more verbose compared to JavaScript
⚠️ Requires importing additional libraries for structured logging

3. Best Practices for Logging

✔️ Define clear log levels: Info / Warn / Error / Debug
✔️ Include timestamps and context in logs to analyze production issues
✔️ Separate log output based on environment:

• Development: console
• Production: file or remote logging
  ✔️ Use structured logging (JSON format) for easy parsing and monitoring
  ✔️ Avoid logging sensitive data such as passwords, tokens, or personal information

4. Comparison: JavaScript vs Go Logging

Recommendation:
✔️ Web apps / frontend-heavy apps → Use Node.js + Winston/Pino
✔️ Backend / server / microservices → Use Go + Logrus/Zap

Next Episode

In EP.28 of JS2GO, we will explore Advanced Error Handling: Stack Trace and Logging to help you debug and analyze issues in your system like a pro.

Read more

• Golang The Series

• JS2GO

• 10 Eps That Will Make You a Pro Tailwind CSS Overnight

🔵 Facebook: Superdev Academy

🔴 YouTube: Superdev Academy

📸 Instagram: Superdev Academy

🎬 TikTok: https://www.tiktok.com/@superdevacademy?lang=th-TH

🌐 Website: https://www.superdevacademy.com/en