Never Miss an Error: Get Node.js Logs and Alerts on Your Phone via Telegram

In modern Node.js and Next.js applications, robust logging is essential for more than just debugging – it's key to maintaining healthy, high-performing production systems. Proper logs allow you to quickly identify issues (error tracking), monitor performance metrics, and understand application behavior in real time. For example, if a critical error occurs on your server, you want to know immediately; relying on only basic logs or delayed email reports isn't enough. Real-time alerts (like a message to your phone) can notify you of critical failures instantly, so you can react before minor issues escalate. In short, advanced logging and alerting give development teams the visibility and response time needed to keep applications running smoothly even as they grow in complexity. The Drawbacks of Using console.log in Production Many developers start with simple console.log statements for debugging, but traditional logging via the console quickly shows its limitations in production environments. The Node.js console provides no concept of log severity or filtering – everything is just printed to stdout or stderr with minimal formatting. This means you can't easily distinguish an error from an info message, and there's no built-in way to turn off verbose logs or focus on critical ones. The output is unstructured (often just plain text), lacking standardized timestamps or JSON formatting, which makes it hard to parse or search when troubleshooting issues across many log lines. Furthermore, console.log has no mechanism for remote or real-time alerts – it's purely local output. If something goes wrong in production, you're relying on manually checking log files or terminal output after the fact. There's no immediate notification to your team or integration with monitoring tools. Another challenge is that sprinkling console.log everywhere can clutter your code and even impact performance (especially if left in production code paths), since writing to console is synchronous and can be slow when logging extensively. Overall, while console.log is fine for quick local debugging, it’s “wholly unsuitable for serious production logging” without features like log levels, structured output, and customizable destinations. Introducing LogPro: A Modern Node.js Logging Package for TypeScript To address these logging challenges, LogPro comes into play as a modern solution. LogPro is a minimalistic, structured logging library built for Node.js applications written in TypeScript. It is designed from the ground up to provide a production-grade logging experience out-of-the-box, going far beyond console.log in capability. With LogPro, developers get a clean API for sending structured log events and the flexibility to route those logs to various outputs – including real-time channels like Telegram. How LogPro Solves Common Logging Problems: LogPro brings features that directly tackle the shortcomings of traditional logging. It implements multiple log levels (so you can differentiate debug information from errors and fatal issues), formats logs as structured JSON for easy analysis, and allows attaching contextual metadata to every log (so you know which user or request an error pertains to, for instance). It also automatically adjusts its format and detail based on the environment – for example, you can have colorful, readable logs during development and compact JSON logs in production. Crucially, LogPro supports custom transports – meaning you can send logs to external services. One of its standout capabilities is the ability to send important log messages directly to Telegram, enabling instant alerts for critical events. In short, LogPro aims to be a one-stop logging package for Node.js/Next.js developers who need more power and polish in their logging system. Key Features of LogPro for Production-Grade Logging LogPro offers a suite of features tailored for professional logging needs in Node.js and Next.js apps: Structured JSON logging – Logs are output in JSON format for easy parsing and analysis by log management systems. This means each log entry can include fields like timestamp, level, message, and context in a machine-readable way. No more scraping unstructured text to extract details. Multiple log levels – Support for levels like debug, info, warn, error, and fatal to categorize logs by severity. You can filter or suppress lower-priority messages in production, while still logging verbosely during development. This ensures critical errors surface when it matters, without drowning in noise. Contextual data support – Ability to attach metadata (context) to logs consistently. For example, you might include a user ID, request ID, or other relevant info with each log. LogPro makes it easy to pass a context object that will be merged into the log output, so you have richer information for debugging and auditing. Environment-aware configuration – The logger can adjust automatically based on NO

Apr 1, 2025 - 16:43

Never Miss an Error: Get Node.js Logs and Alerts on Your Phone via Telegram

In modern Node.js and Next.js applications, robust logging is essential for more than just debugging – it's key to maintaining healthy, high-performing production systems. Proper logs allow you to quickly identify issues (error tracking), monitor performance metrics, and understand application behavior in real time. For example, if a critical error occurs on your server, you want to know immediately; relying on only basic logs or delayed email reports isn't enough. Real-time alerts (like a message to your phone) can notify you of critical failures instantly, so you can react before minor issues escalate. In short, advanced logging and alerting give development teams the visibility and response time needed to keep applications running smoothly even as they grow in complexity.

The Drawbacks of Using `console.log` in Production

Many developers start with simple console.log statements for debugging, but traditional logging via the console quickly shows its limitations in production environments. The Node.js console provides no concept of log severity or filtering – everything is just printed to stdout or stderr with minimal formatting. This means you can't easily distinguish an error from an info message, and there's no built-in way to turn off verbose logs or focus on critical ones. The output is unstructured (often just plain text), lacking standardized timestamps or JSON formatting, which makes it hard to parse or search when troubleshooting issues across many log lines.

Furthermore, console.log has no mechanism for remote or real-time alerts – it's purely local output. If something goes wrong in production, you're relying on manually checking log files or terminal output after the fact. There's no immediate notification to your team or integration with monitoring tools. Another challenge is that sprinkling console.log everywhere can clutter your code and even impact performance (especially if left in production code paths), since writing to console is synchronous and can be slow when logging extensively. Overall, while console.log is fine for quick local debugging, it’s “wholly unsuitable for serious production logging” without features like log levels, structured output, and customizable destinations.

Introducing LogPro: A Modern Node.js Logging Package for TypeScript

To address these logging challenges, LogPro comes into play as a modern solution. LogPro is a minimalistic, structured logging library built for Node.js applications written in TypeScript. It is designed from the ground up to provide a production-grade logging experience out-of-the-box, going far beyond console.log in capability. With LogPro, developers get a clean API for sending structured log events and the flexibility to route those logs to various outputs – including real-time channels like Telegram.

How LogPro Solves Common Logging Problems: LogPro brings features that directly tackle the shortcomings of traditional logging. It implements multiple log levels (so you can differentiate debug information from errors and fatal issues), formats logs as structured JSON for easy analysis, and allows attaching contextual metadata to every log (so you know which user or request an error pertains to, for instance). It also automatically adjusts its format and detail based on the environment – for example, you can have colorful, readable logs during development and compact JSON logs in production. Crucially, LogPro supports custom transports – meaning you can send logs to external services. One of its standout capabilities is the ability to send important log messages directly to Telegram, enabling instant alerts for critical events. In short, LogPro aims to be a one-stop logging package for Node.js/Next.js developers who need more power and polish in their logging system.

Key Features of LogPro for Production-Grade Logging

LogPro offers a suite of features tailored for professional logging needs in Node.js and Next.js apps:

Structured JSON logging – Logs are output in JSON format for easy parsing and analysis by log management systems. This means each log entry can include fields like timestamp, level, message, and context in a machine-readable way. No more scraping unstructured text to extract details.
Multiple log levels – Support for levels like debug, info, warn, error, and fatal to categorize logs by severity. You can filter or suppress lower-priority messages in production, while still logging verbosely during development. This ensures critical errors surface when it matters, without drowning in noise.
Contextual data support – Ability to attach metadata (context) to logs consistently. For example, you might include a user ID, request ID, or other relevant info with each log. LogPro makes it easy to pass a context object that will be merged into the log output, so you have richer information for debugging and auditing.
Environment-aware configuration – The logger can adjust automatically based on NODE_ENV. For instance, in development you might get human-friendly output with colors and full debug details, while in production LogPro defaults to JSON format and a higher log level (e.g. only info and above). This adaptive behavior means you get the right balance of verbosity vs. clarity depending on where your app is running.
Human-readable formatting (for dev) – In non-production environments, LogPro can pretty-print logs with colors and indentation. This improves readability during local development or testing, making it easier to spot issues without manually parsing JSON.
Zero dependencies core – The core logging functionality has no external runtime dependencies. This keeps the library lightweight and performance-friendly. (Transports for optional features are add-ons, so if you don't use Telegram or others, you aren't paying a cost for them.)
Extensible transports (e.g., Telegram) – LogPro supports adding custom transports to send logs to various destinations. Out of the box, it provides a Telegram transport that can push selected log messages to a Telegram chat or channel. This is extremely useful for setting up real-time alerts: for example, you can configure LogPro to send all errors or critical issues to your team's Telegram group instantly.

All these features make LogPro a powerful Node.js logging package for serious applications. It's especially appealing to TypeScript developers, as it is written in TypeScript and provides type definitions, ensuring type-safe configuration and usage.

Setting Up LogPro in a Node.js/Next.js Project (TypeScript)

Getting started with LogPro is straightforward. Let's walk through how to add LogPro to a Node.js or Next.js application and use it to improve your logging.

Installation

First, install the LogPro package (available on npm under @xenral/logpro):

npm install @xenral/logpro

(If you prefer Yarn: yarn add @xenral/logpro.)

Because LogPro is built with TypeScript, you'll get type definitions automatically with the package.

Basic Usage in TypeScript

After installing, you can import the logger and start logging with different levels right away. In a Next.js app, you might do this in an API route or any server-side code. In a plain Node.js app, you might set this up in your main server file. For example:

import { logger } from '@xenral/logpro';

// Basic logging usage
logger.info('Application started');  // informational log
logger.warn('Connection timeout, retrying...');  // warning condition
logger.error('Failed to connect to database');  // error condition

// Logging with context data
logger.info('User logged in', { userId: '123', role: 'admin' });

// Logging an error with stack trace
try {
  // some operation that throws
  throw new Error('Something went wrong');
} catch (error) {
  logger.error('Operation failed', { operation: 'data-import' }, error);
}

In the above code:

We import the default logger from LogPro. By default, this logger is environment-aware. In development, these logs would appear in the console in a colored, pretty format. In production (when NODE_ENV is "production"), they would appear as JSON lines which are easier to ship to log aggregators.
We log messages at various levels: .info() for a general event, .warn() for a potential issue, and .error() for a failure. Each method will include a timestamp and other metadata automatically.
We include additional context information in some logs (like user ID and role on a login event). LogPro will merge this context into the log output (e.g., adding userId and role fields in the JSON), which is extremely useful for debugging issues related to specific users or operations.
When catching an exception, we pass the error object as a third argument to logger.error(). LogPro will capture the stack trace and error message and include them in the log entry. This means you get the full error details in your logs without needing a separate console.error or manual stack print. Logging unexpected errors with stack traces is crucial for post-mortem analysis in production, and LogPro makes it simple.

This basic setup already greatly improves the quality of your Next.js production logs or Node.js service logs. You'll have structured, leveled logs that you can filter and analyze. But LogPro can do more – particularly when it comes to real-time alerting for critical issues.

Configuring Telegram Alerts for Real-Time Logging

One of LogPro's killer features is the ability to send log messages to Telegram. This allows you to get instant notifications on your phone or Telegram desktop app whenever something important happens (e.g., an error or a specific event in your app). Setting this up involves a few steps:

Install Telegram Bot API dependency: LogPro's Telegram transport is built on the popular Node Telegram Bot API. Install it in your project with: npm install node-telegram-bot-api (this is an optional dependency).
Create a Telegram bot: Use the official @BotFather bot on Telegram to create a new bot for your application. BotFather will walk you through naming your bot and will provide you with a bot token (a long string) once created. Save this token securely – treat it like a password.
Get a chat ID for alerts: Decide where you want the alerts to go – it could be a private chat with yourself or a group/channel for your dev team. You will need the chat ID number for that destination. If it's a chat with yourself, you can obtain your own chat ID by using a service like @username_to_id_bot on Telegram (just start it and follow instructions to get your ID). For a group, you might need to add the bot to the group and then get the group's ID similarly.
Add the Telegram transport in code: Now you can use LogPro's TelegramTransport to send logs to Telegram. You'll configure it with the token and chat ID from the above steps.

Here's an example of adding a Telegram transport to the logger in code:

import { getLogger, LogLevel, TelegramTransport } from '@xenral/logpro';

// (Make sure node-telegram-bot-api is installed as mentioned above)

// Create or get a logger instance (could be your main app logger)
const logger = getLogger('app');

// Create a Telegram transport for LogPro
const telegramTransport = new TelegramTransport({
  token: 'YOUR_TELEGRAM_BOT_TOKEN',    // from BotFather
  chatId: 'YOUR_CHAT_ID',             // from @username_to_id_bot or similar
  minLevel: LogLevel.ERROR,           // minimum level to send (e.g., only errors and above)
  // Optional: filter function to fine-tune which logs are sent
  filter: (entry) => entry.context.urgent === true
});

// Attach the Telegram transport to the logger
logger.addTransport(telegramTransport);

// Example log messages
logger.info('Application started'); 
// ^ This info log goes to console (or file), but not to Telegram (because of minLevel ERROR).

logger.error('Database connection failed', { 
  urgent: true, 
  dbHost: 'prod-db-1' 
});
// ^ This error log will appear in console and also trigger a Telegram alert, 
// since its level is ERROR and we marked it as urgent in context (matching our filter).

In this configuration:

We import TelegramTransport from LogPro.
We instantiate it with the bot token and target chatId. We also set minLevel: LogLevel.ERROR to ensure that only logs of level ERROR or FATAL (the highest severities) are sent to Telegram. This prevents spamming Telegram with debug or info logs.
An optional filter function is shown: in this case, we're only sending logs to Telegram if the log entry's context has urgent: true. This is just an example of how you can tag certain logs for alerts. You could decide to send all errors, or perhaps all logs on a certain logger name or context property – it's customizable.
We then add this transport to our logger. From that point on, any log message that meets the criteria (level and filter) will be forwarded to Telegram in addition to whatever other outputs the logger has (console, files, etc.).
In the example, an info log of "Application started" would not go to Telegram (it's below ERROR level). But an error log about a database failure will be sent to Telegram because it's an error-level and we flagged it as urgent.

After deploying this, you'll start receiving Telegram messages from your bot whenever such an error occurs. The message typically contains the log level, the logger name (in this case "app"), the text message, and any context (e.g., dbHost) you included. This immediate visibility can be a game-changer for production support – instead of waiting to discover an issue via user reports or digging through log files, you get proactively alerted in real time.

Tip: Make sure to keep your bot token secure. Do not commit it to your repository. Use environment variables or a secrets management system to load the token and chat ID. For example, you might set process.env.TG_BOT_TOKEN and process.env.TG_CHAT_ID in your deployment environment, and pass those into the TelegramTransport config instead of hardcoding the strings. This keeps sensitive credentials out of your codebase.

Best Practices for Production Logging with LogPro

Using a powerful logging tool like LogPro effectively requires following some best practices to get the most out of it while keeping your application secure and performant. Here are some recommendations:

Use appropriate log levels and avoid noise: In production, it's usually wise to log at info level and above, reserving debug logs for development or troubleshooting specific issues. LogPro lets you set a global minimum level (e.g., using logger.setLevel(LogLevel.INFO) or via environment) so that verbose logs don't overwhelm your production log files or alerts. This ensures you capture important events without the noise. You can elevate the level temporarily (to debug) if investigating an incident, but remember to revert back. Also, take advantage of LogPro's levels – use warn for recoverable issues or suspicious situations, error for actual errors, and fatal if the app might crash or terminate. Defining clear severity levels helps downstream log analysis and alerting systems work better.
Always capture errors with stack traces: When an exception is caught or an error occurs, make sure to log it with the error object (as shown in the try/catch example above). The stack trace and error message are invaluable for debugging. LogPro's API is designed to include error information, so pass the error object to logger.error() or logger.fatal(). Also consider logging a brief message explaining the context of the error (e.g., what the app was trying to do) along with the error – this combination of context + stack trace is ideal. By diligently logging errors, you'll have an auditable history of exceptions and can perform root cause analysis later.
Avoid logging sensitive information: Security is as important as utility when it comes to logs. Never expose confidential or personal data in your logs. This includes passwords, API keys, authentication tokens, credit card numbers, or personal user information. Even IP addresses or email addresses might be considered sensitive (PII) in some contexts. A famous incident in 2018 involved a company accidentally logging plaintext user passwords internally, highlighting how dangerous careless logging can be. Treat logs as data that could potentially leak; if your logs are forwarded to external systems (like a cloud log service or Telegram), the risk is even higher. With LogPro, you have fine control over what you include in context. Be mindful to exclude or sanitize sensitive fields. For instance, if you have a user object, log a user ID instead of the full user details. If you must log sensitive data for debugging, consider using LogPro's ability to filter or transform logs (or do it manually) to redact those values. Always err on the side of caution: "Your application logs should never capture data like passwords, credit card details, or authorization tokens."
Protect your alert channels: If you're using the Telegram integration or any external alerting, ensure that the channel is private or only accessible to your team. Telegram bots cannot send messages to a user who hasn't started a conversation with them or a group that hasn't added them, so there's some inherent security, but be aware that whatever you send to Telegram is going through an external service. Do not send extremely sensitive data over these alerts. The goal of alerts is to inform you that something went wrong, with enough detail to take action or look deeper in your secure logs. Think of Telegram alerts as a heads-up; the full context might still reside in your application logs or error tracking system which are more protected.
Monitor performance impact: LogPro is designed to be lightweight (no dependencies and efficient JSON serialization), but any logging has overhead. In very high-throughput parts of your application, be mindful not to log excessively (for example, in a tight loop or for every single web request in a very high QPS service, you might want to sample logs). Use log levels wisely to avoid performance degradation. The benefit of structured logging is you can later aggregate and analyze logs, so you might not need to log every detail of every request, just the significant events. If you use async logging or buffer logs to send out (LogPro could be extended for that), ensure those mechanisms are reliable under load.

By following these practices, you'll maintain a high signal-to-noise ratio in your logs, keep your application secure, and ensure your logging infrastructure (and alerting via Telegram) remains sustainable as traffic grows.

Conclusion: Elevate Your Node.js Monitoring with LogPro

As developers, we can't improve what we don't monitor. Advanced logging is a cornerstone of effective application monitoring and error recovery. If you're building serious applications with Node.js or Next.js, relying solely on console.log is a risk you don't want to take – you might miss critical insights or lose precious time during an outage. Embracing a production-grade logging tool like LogPro can transform how you track your app’s health in production. You'll gain structured, meaningful logs, real-time visibility into issues via Telegram alerts, and the confidence that no error will slip by unnoticed.

LogPro is easy to integrate, highly configurable, and purpose-built for TypeScript Node.js projects. It addresses the pain points of traditional logging while adding modern features that save time and headaches for developers. Whether you need to debug atricky issue, audit user actions, or get instant notifications of failures, LogPro has you covered.

Don’t wait for the next production fire to realize your logging is inadequate. Take proactive steps now: try LogPro in your Node.js/Next.js project and experience the difference in your production monitoring. With better logs and timely alerts, you'll be ready to tackle problems head-on and ensure your application runs smoothly 24/7. Happy logging!

References

LogPro GitHub Repository – A minimalistic, structured logging utility for TypeScript projects (GitHub - xenral/LogPro: A minimal, structured logging utility for TypeScript projects)
Better Stack Community – 11 Best Practices for Logging in Node.js (Ayooluwa Isaiah, Oct 2023) (11 Best Practices for Logging in Node.js | Better Stack Community)
Medium (Arunangshu Das, Dec 2024) – What Is the Best Way to Manage Node.js Application Logs in Production? (What Is the Best Way to Manage Node.js Application Logs in Production? | by Arunangshu Das | Medium)