10 лучших библиотек ведения журналов Node.js

В этом блоге мы обсудим ценность использования библиотек ведения журналов и рассмотрим 10 самых популярных инструментов ведения журналов, с которыми мы столкнулись для Node.js. В @playerzero мы часто используем библиотеки ведения журнала node.js для создания и управления событиями журнала. Узнайте больше о том, как мы внедряем наш уникальный подход к мониторингу того, что важно для внешних и внутренних приложений, сегодня https://www.playerzero.app/

* Пино * Уинстон * Баньян * Морган * Логарифмический уровень * Лог4джс * Нпмлог * Рев * Трейсер * Сигнал

С точки зрения высокого уровня ведение журнала Node.js важно, поскольку оно помогает разработчикам отслеживать события и производительность своего приложения, диагностировать и устранять проблемы, отслеживать поведение системы и принимать обоснованные решения. Ведение журнала обеспечивает запись активности приложения, позволяя разработчикам выявлять и устранять проблемы, понимать поведение пользователей и повышать общую производительность и стабильность системы. Ведение журналов также может быть полезно в производственных средах для обнаружения и исправления ошибок, мониторинга производительности системы и обнаружения инцидентов безопасности.

Журналирование и отслеживание

Всякий раз, когда в приложении что-то идет не так, разработчики могут отследить его источник с помощью трассировки стека. Но… полагаться только на трассировку стека можно только наполовину. Трассировка предоставит вам информацию о выполнении приложения, включая поток запросов, запросы к базе данных, внешние вызовы API и показатели производительности, которые могут быть весьма полезными. Как правило, трассировки используются для понимания поведения приложения на детальном уровне и выявления узких мест в производительности.

Ведение журнала заполняет другую половину картины. Ведение журнала — это процесс записи сообщений и событий, связанных с приложением, таких как ошибки, предупреждения, показатели производительности и отладочная информация. Вход в Node.js используется для диагностики проблем, понимания поведения пользователей и повышения общей производительности и стабильности приложения. Он также обеспечивает запись активности в приложении, что позволяет разработчикам выявлять и устранять проблемы и принимать более обоснованные решения.

Зачем использовать библиотеки ведения журналов для Node.js?

Есть несколько причин, по которым вам следует использовать библиотеки ведения журналов Node.js:

1. Улучшенная отладка: библиотеки журналов предоставляют подробную информацию об ошибках и проблемах, что позволяет разработчикам более эффективно диагностировать и устранять проблемы.
2. Улучшенная видимость: ведение журнала обеспечивает четкое представление о поведении и производительности приложения, позволяя разработчикам принимать обоснованные решения и улучшать систему.
3. Повышение производительности. Библиотеки ведения журналов можно оптимизировать для повышения производительности, уменьшая накладные расходы на ведение журналов и повышая общую производительность системы.
4. Централизованное ведение журналов. Многие библиотеки журналов позволяют записывать журналы на централизованный сервер журналов, что упрощает сбор, просмотр и анализ данных журналов.
5. Настройка. Библиотеки журналов можно настроить в соответствии с конкретными потребностями, такими как настраиваемые уровни журналов, выходные форматы и фильтры.

Уровни ведения журнала

Уровни ведения журнала — это способ классификации важности или серьезности сообщений журнала. Как правило, существует несколько уровней, от критических ошибок до информационных сообщений, и каждый уровень связан с числовым значением, которое можно использовать для фильтрации сообщений журнала в библиотеке. Вот наиболее распространенные уровни:

FATAL уровень журнала

Возможно, неудивительно, что уровень журнала FATAL — это уровень серьезности, указывающий на критическую ошибку в приложении. Это означает, что журналы с уровнем FATAL указывают, что приложение может не может продолжать нормально работать без вмешательства разработчика.

ОШИБКА уровень журнала

Уровень журнала ERROR указывает, что приложение в настоящее время может работать, НО оно сталкивается с проблемой. Обычно это указывает на то, что требуемая задача в приложении не удалась — произошло исключение, неожиданное поведение или неправильные входные данные.

ПРЕДУПРЕЖДЕНИЕ уровень журнала

ПРЕДУПРЕЖДЕНИЕ — это менее серьезный уровень логирования, чем ERROR, но, тем не менее, его нельзя игнорировать. Журналы WARN можно использовать для упреждающего выявления проблем и предотвращения их усугубления, поскольку они указывают на то, что что-то в вашем приложении может стать катализатором более серьезной проблемы.

INFO уровень журнала

Уровень журнала INFO — это тип сообщения журнала, который используется в системах ведения журнала для обозначения общего информационного сообщения. Обычно он используется для регистрации рутинных, ожидаемых событий в приложении или системе, таких как запуск процесса, завершение задачи или изменение состояния системы. Эти оповещения обычно можно игнорировать, поскольку они предназначены для подтверждения того, что приложение работает правильно.

ОТЛАДКА уровень журнала

Обычно уровень журнала DEBUG предоставляет информацию, полезную исключительно в процессе отладки. Журналы DEBUG — это наиболее подробный тип сообщений журнала, которые предоставляют детальное представление о внутренней работе приложения. Основная цель журналов DEBUG — помочь разработчикам понять, что делает система, выявить ошибки и проблемы, а также диагностировать проблемы.

10 лучших библиотек журналирования Node.js & как начать с ними

№1. Пино

Преимущества Pino

Pino — давно зарекомендовавший себя и очень популярный инструмент для ведения журналов, набравший более 10,9 тысяч звезд на Github и миллионы загрузок на npm. Pino — это популярная библиотека ведения журналов для Node.js, поскольку она предоставляет несколько ключевых функций, которые делают ее подходящей для использования в приложениях Node.js:

* Быстрый. Pino разработан, чтобы быть быстрым и легким, с упором на производительность. Он использует двоичный формат для сообщений журнала, что позволяет быстро и эффективно генерировать выходные данные журнала. * Структурированные журналы. Pino регистрирует сообщения в формате JSON, что упрощает анализ, фильтрацию и анализ данных журнала. Это упрощает поиск, визуализацию и анализ данных журналов, а также интеграцию данных журналов в другие системы. * Простота расширения. Pino обладает широкими возможностями расширения и включает ряд встроенных подключаемых модулей, которые можно использовать для добавления дополнительных функций, таких как запись данных журнала в файл или отправка данных журнала. на удаленный сервер. * Низкие накладные расходы. Pino — это высокоэффективная библиотека ведения журналов Node.js благодаря минимальному использованию ресурсов. Процесс логирования с Pino постепенно накапливает сообщения, что приводит к троттлингу приложения и уменьшению количества запросов в секунду. Регулирование — это метод, при котором функция, связанная с событием, запускается только один раз в течение указанного периода времени, даже если событие запускается несколько раз. * Транспорт. Pino предлагает различные варианты отправки журналов, включая запись в файлы, отображение в консоли и использование таких платформ, как Sentry, Azure Application Insights и CouchDB.

Чтобы использовать Pino в приложении Node.js, выполните следующие действия:

Установка Pino

Чтобы установить Pino, просто установите его, выполнив следующую команду в новом каталоге:

npm install pino

Импорт — в приложении Node.js импортируйте Pino, добавив следующую строку кода вверху файла:

const pino = require('pino');

Использование Pino

Инициализация — инициализируйте Pino, создав экземпляр регистратора, например:

const logger = pino({
  level: 'info'
});

Этот сценарий создает журналы с уровнем ведения журнала INFO и выше на консоли.

Установив уровень информации, Pino будет регистрировать сообщения с уровнем ведения журнала INFO, WARN, ERROR и FATAL. Сообщения с уровнем ведения журнала ниже INFO, например DEBUG, не будут регистрироваться.

Этот код создает только экземпляр регистратора Pino с уровнем журнала INFO. Сообщения журнала не генерируются и не отображаются, пока вы не зарегистрируете что-либо с помощью экземпляра регистратора. Например:

logger.info('This is an info message');

Это приведет к следующему выводу на консоли:

{"level":30,"time":1624825088703,"msg":"This is an info message","pid":1234,"hostname":"my-machine"}

Данные журнала, отображаемые на консоли, включают уровень журнала, отметку времени записи, записываемое сообщение, идентификатор журнала и имя хоста.

Ведение журнала. Вы можете использовать экземпляр logger для регистрации других сообщений в вашем приложении. Например:

logger.warn('This is a warning message');
logger.error('This is an error message');

Вывод — по умолчанию Pino регистрируется в консоли. Если вы хотите изменить выходные данные, вы можете использовать один из доступных транспортов Pino, о которых мы упоминали ранее, например запись в файл, отправка журналов в удаленную службу, например Sentry, или с помощью Azure Application Insights. Для получения дополнительной информации вы можете обратиться к разделу Pino «Известные транспорты».

Красивая установка Pino

Функция базового форматирования Pino pino-pretty NDJSON — это отличный простой форматтер для журналов Pino, который легко настроить. Вот как это сделать:

Шаг 1. Установите pino-pretty как зависимость в вашем проекте Node.js, выполнив в терминале следующую команду:

npm install pino-pretty

Шаг 2. Импортируйте pino-pretty в свое приложение Node.js, добавив следующую строку кода вверху файла:

const pino = require('pino');
const pinoPretty = require('pino-pretty');

const logger = pino({
level: 'info'
});

logger.pipe(pinoPretty());

С помощью этих двух фрагментов кода вы установили pino-pretty и настроили его для форматирования журналов Pino. Теперь вы можете использовать экземпляр регистратора для регистрации сообщений в своем приложении, и журналы будут отображаться в удобном для восприятия человеком формате на консоли.

Узнайте больше об отладке с помощью Pino в Как отлаживать Node.js с лучшими доступными инструментами от @RisingStack

#2. Уинстон

Преимущества Winston

Winston — очень популярная библиотека ведения журналов для Node.js, получившая более 20 тысяч звезд на GitHub. Winston — это уникальная библиотека ведения журналов в экосистеме Node.js благодаря своему обширному набору функций и простоте использования. Вот некоторые из причин, по которым Уинстон выделяется:

* Гибкость. Winston обладает широкими возможностями настройки и предоставляет различные параметры ведения журналов и транспортные механизмы, которые позволяют записывать журналы на несколько выходов, например на консоль, в файл или на удаленный сервер. * Журналы с возможностью запроса. Winston предоставляет архив журналов с возможностью запроса, что упрощает поиск и анализ журналов. * Простота в использовании. У Winston есть простой и удобный API, который упрощает начало работы с ведением журнала в приложении Node.js. Он предоставляет минимальный набор основных функций, а также позволяет разработчикам расширять и настраивать функции ведения журнала по мере необходимости. * Хорошо документировано. У Winston есть исчерпывающая документация, в которой содержится подробная информация о его API, а также ряд примеров и руководств, которые помогут разработчикам быстро и легко начать работу. * Управляемый сообществом. Winston — это проект с открытым исходным кодом, в котором участвует большое и активное сообщество разработчиков, что помогает обеспечить хорошее обслуживание библиотеки, отсутствие ошибок и ее обновление в соответствии с последними тенденциями. новейшие тенденции и технологии.

Установка Winston

Чтобы установить Winston в свой проект Node.js, вы можете использовать диспетчер пакетов npm, выполнив в терминале следующую команду:

npm install winston

Использование Winston

После завершения установки вы можете импортировать и использовать Winston в своем коде Node.js, включив следующую строку:

const winston = require('winston');

Затем вы можете использовать библиотеку Winston для настройки и создания экземпляров журналов, например:

const logger = winston.createLogger({
level: 'info',
format: winston.format.json(),
transports: [
new winston.transports.Console()
]
});

При этом создается экземпляр регистратора с информационным уровнем и консольным транспортом. Вы можете использовать этот экземпляр регистратора для регистрации сообщений в вашем приложении, например:

logger.info('Hello World');

Это запишет сообщение Hello World в консоль с уровнем информационного журнала.

Уровни ведения журнала в Winston

В Winston предусмотрено шесть уровней ведения журнала по умолчанию, организованных в соответствии с рекомендациями, изложенными в документе RFC5424. Уровням назначается числовой приоритет, при этом самому высокому уровню серьезности присваивается самый низкий номер. Шесть уровней и соответствующие им значения приоритета:

{
error: 0,
warn: 1,
info: 2,
http: 3,
verbose: 4,
debug: 5,
silly: 6
}

Для каждого из шести уровней ведения журнала существует соответствующий метод объекта ведения журнала:

logger.error('error');
logger.warn('warn');
logger.info('info');
logger.verbose('verbose');
logger.debug('debug');
logger.silly('silly');

Вы также можете передать строку, представляющую уровень ведения журнала, в метод log():

logger.log('error', 'error message');
logger.log('info', 'info message');

Свойство level в logger определяет, какие сообщения журнала будут передаваться настроенным вами транспортам. Например, если для свойства level задано значение info, будут записываться только записи журнала с серьезностью info или выше, а все остальные быть лишенным приоритета. Это означает, что в текущей конфигурации будут выводиться только сообщения журнала с уровнями info, warn и error.

#3. Баньян

Преимущества Баньяна

Bunyan – это уникальная библиотека ведения журналов для Node.js, поскольку она нацелена на то, чтобы сделать данные журналов более структурированными и удобочитаемыми (это достигается за счет сериализации журналов в виде объектов JSON, а не в виде простого текста). Вот почему у Баньяна 7 тысяч звезд на Github:

1. Формат JSON. В отличие от некоторых других библиотек журналов, Bunyan записывает данные в формате JSON, что упрощает анализ и интеграцию с другими инструментами и платформами.
2. Гибкие уровни ведения журнала. Bunyan поддерживает несколько уровней ведения журнала с гибкими параметрами для управления уровнем серьезности журнала и пороговым значением.
3. Сериализация. В Bunyan существует функция, называемая сериализацией, при которой функции преобразуют объект JavaScript в объект, представляемый в формате JSON. Это позволяет конкретному экземпляру регистратора иметь сериализатор, который связывает имя поля записи журнала с функцией сериализации.
4. Простой в использовании API. Bunyan предоставляет простой и удобный в использовании API для ведения журналов, что делает его доступным для разработчиков любого уровня квалификации.
5. Подключаемые модули и транспортные средства. Bunyan поддерживает различные подключаемые модули и транспортные средства, такие как консоль, файл, HTTP и электронная почта, что упрощает настройку вывода журнала в соответствии с конкретными потребностями и требованиями.< /li>

Установка Баньяна

Чтобы установить Bunyan, вы можете запустить следующую команду в терминале или командной строке:

npm install bunyan

Это установит библиотеку Bunyan и ее зависимости в ваш проект Node.js. После установки вы можете включить библиотеку в свой код и начать ее использовать.

Использование Баньяна

Импортируйте Bunyan в свой проект — в верхней части файла JavaScript добавьте следующую строку:

const bunyan = require('bunyan');

Создайте экземпляр регистратора. Затем создайте экземпляр регистратора, используя следующий код:

const logger = bunyan.createLogger({
name: 'my-app-name',
level: 'info'
});

В этом примере name — это имя вашего приложения, а level указывает минимальный уровень журналов, которые вы хотите видеть.

Зарегистрировать сообщение. Чтобы записать сообщение, просто вызовите один из методов журнала Bunyan, например info, warn или error, и передайте сообщение, которое вы хотите зарегистрировать, например так:

logger.info('This is an info log message');
logger.warn('This is a warn log message');
logger.error('This is an error log message');

Запустите свой код — наконец, запустите свой код, и вы должны увидеть зарегистрированные сообщения в консоли.

По умолчанию Bunyan выводит журналы в формате JSON, что упрощает разбор и анализ журналов с помощью инструментов управления журналами. Вы также можете настроить формат с помощью параметра потоков Bunyan.

#4. Морган

Преимущества Моргана

Morgan — это уникальная библиотека ведения журналов для Node.js по нескольким причинам, главным образом из-за ее уникального позиционирования в качестве ПО промежуточного слоя. Это, среди прочих причин, сделало его очень популярным, с 7,3 тысячами звезд на GitHub на момент написания нашей статьи. Вот несколько причин, по которым Морган так популярен:

1. Промежуточное ПО. Morgan работает как промежуточное ПО в среде Node.js Express, что упрощает интеграцию в существующие приложения на основе Express.
2. Настраиваемость. Morgan предлагает широкий спектр параметров настройки, от формата журнала до пользовательских токенов, что позволяет разработчикам адаптировать свои журналы к своим конкретным потребностям.
3. На основе потоков. Morgan может записывать данные журнала в различные потоки вывода, включая консоль, файлы и даже удаленные серверы.
4. Быстрый и легкий. Morgan разработан, чтобы быть быстрым и легким, что делает его подходящим для приложений с высоким трафиком, где производительность имеет решающее значение.
5. Журналирование HTTP-запросов. Morgan специально разработан для регистрации HTTP-запросов и ответов, что полезно для отладки и анализа производительности веб-сервера.

Установка Моргана

Начните с установки пакета morgan с помощью npm:

npm install morgan

Использование Моргана

После завершения процесса установки вам необходимо импортировать библиотеку с помощью функции «требовать», а затем интегрировать ее в свое приложение Express.js в качестве промежуточного программного обеспечения.

Код для этого будет выглядеть следующим образом:

var morgan = require('morgan');
app.use(morgan('dev'));

Аргумент «dev» — это параметр формата, предоставленный Morgan. Morgan предлагает пять различных форматов ведения журнала, в том числе:

1. tiny имеет мизерный результат.
2. short по умолчанию включает время отклика и сокращает журнал.
3. dev предоставляет краткий вывод с цветовой кодировкой для использования во время разработки.
4. common также использует комбинированный вывод журнала Apache.
5. combined использует стандартный объединенный вывод журнала Apache.

Вы можете выбирать между этими форматами, используя соответствующий аргумент при интеграции Morgan в ваше приложение, как показано ниже:

app.use(morgan('combined'));
app.use(morgan('common'));
app.use(morgan('dev'));
app.use(morgan('short'));
app.use(morgan('tiny'));

#5. Уровень журнала

Преимущества уровня логирования

Loglevel немного менее популярен, чем некоторые другие варианты, перечисленные здесь, с 2,4 тыс. звездочек на Github, но, тем не менее, он остается отличной и легкой библиотекой ведения журналов. Вот несколько причин, по которым loglevel является уникальной библиотекой ведения журналов для Node.js:

1. Минимальный объем кода. loglevel – это очень легкая библиотека, что делает ее идеальной для ситуаций, когда требуется минимальный объем кода.
2. Уровни динамического ведения журнала. Уровень журнала обеспечивает динамические уровни ведения журнала, что позволяет изменять уровень ведения журнала во время выполнения, упрощая переключение между различными уровнями ведения журнала без необходимости изменения кода.< /li>
3. Простой API. API уровня ведения журнала прост и обеспечивает простой в использовании и гибкий способ регистрации сообщений.
4. Совместимость с браузером. Уровень ведения журнала совместим как с Node.js, так и с веб-браузерами, что делает его универсальным выбором для ведения журнала в различных средах.
5. Межплатформенная совместимость. Уровень ведения журнала основан на log4js, широко используемой библиотеке ведения журналов, что обеспечивает совместимость на разных платформах.

Установка лог-уровня

Чтобы настроить уровень ведения журнала, необходимо сначала установить его с помощью npm:

npm install loglevel

Использование уровня логирования

Установив его, вы можете импортировать его в свой проект Node.js и начать использовать, установив уровень ведения журнала:

const log = require('loglevel');

log.setLevel(log.levels.ERROR);

Установив уровень журнала ERROR, вы указываете, что в журнал будут записываться только сообщения с уровнем серьезности ERROR. После настройки уровня журнала вы можете использовать следующие методы для регистрации сообщений на разных уровнях:

log.trace('This is a trace message');
log.debug('This is a debug message');
log.info('This is an info message');
log.warn('This is a warning message');
log.error('This is an error message');

Установленный уровень журнала будет определять, какие сообщения будут регистрироваться, а какие будут игнорироваться. Например, если установлен уровень журнала info, будут отображаться только сообщения, зарегистрированные с помощью log.info и log.warn или log.error.< /p>

#6. Log4js

Преимущества Log4js

Конечно, мы не могли упомянуть уровень логирования, не упомянув также его старшего брата, Log4js. Log4js — это библиотека ведения журналов JavaScript, которая была запущена как порт популярной библиотеки ведения журналов Java Log4j. Он был создан, чтобы предоставить аналогичное решение для ведения журнала для приложений JavaScript, и с тех пор эволюционировал, предоставляя расширенные возможности и функции ведения журнала. Вот несколько причин, по которым Log4js так популярен: более 5,6 000 звезд на Github:

* Гибкость в конфигурации. Log4js предлагает ряд вариантов ведения журнала, включая уровни журнала, различные типы приложений (например, консоль, файл, сеть) и возможность указывать разные конфигурации журнала для разных частей приложение. * Пользовательские приложения. Log4js поддерживает создание пользовательских приложений, что позволяет разработчикам расширять библиотеку в соответствии со своими конкретными требованиями к ведению журналов. * Поддержка контекста журнала. Log4js позволяет разработчикам связывать сообщения журнала с дополнительной контекстной информацией, такой как данные запроса пользователя, чтобы сделать сообщения журнала более полезными для отладки. * Динамическая конфигурация уровня журнала. Log4js поддерживает изменение уровня журнала во время выполнения, что упрощает управление журналом в производственной среде. * Интеграция с другими инструментами. Log4js имеет встроенную поддержку популярных инструментов, таких как Logstash и Graylog, что упрощает интеграцию ведения журналов в более широкий рабочий процесс мониторинга и анализа приложений.

Установка Log4js

Чтобы установить Log4js, вы можете использовать диспетчер пакетов npm, выполнив в терминале следующую команду:

npm install log4js

Это установит последнюю версию Log4js и ее зависимости. Затем вы можете запросить библиотеку в своем приложении Node.js и начать использовать ее для регистрации сообщений.

Использование Log4js

Чтобы начать использовать Log4js, сначала добавьте его в свой код и настройте:

const log4js = require('log4js');

log4js.configure({
appenders: {
console: {
type: 'console'
}
},
categories: {
default: { appenders: ['console'], level: 'info' }
}
});

const logger = log4js.getLogger();

Затем вы можете использовать регистратор для регистрации сообщений на разных уровнях:

logger.trace('Entering cheese testing');
logger.debug('Got cheese.');
logger.info('Cheese is Gouda.');
logger.warn('Cheese is quite smelly.');
logger.error('Cheese is too ripe!');
logger.fatal('Cheese was breeding ground for listeria.');

Вот пример использования Log4js для записи сообщений в несколько приложений (консоль и файл) с разными уровнями ведения журнала:

const log4js = require('log4js');

log4js.configure({
appenders: {
console: { type: 'console' },
file: { type: 'file', filename: 'app.log' }
},
categories: {
default: { appenders: ['console'], level: 'info' },
file: { appenders: ['file'], level: 'error' }
}
});

const logger = log4js.getLogger();
const fileLogger = log4js.getLogger('file');

logger.info('This is an informational message');
fileLogger.error('This is an error message');

В этом примере регистратор с категорией «по умолчанию» настроен на регистрацию сообщений с информацией об уровне или выше на консоли. Регистратор с категорией «файл» настроен на регистрацию сообщений с уровнем ошибки или выше в файл. Два регистратора могут использоваться взаимозаменяемо для записи сообщений в соответствующие приложения.

#7. Нпмлог

Преимущества Npmlog

Уникальная ценность npmlog заключается в его простоте и минимальных накладных расходах, что делает его хорошо подходящим для использования в небольших или чувствительных к производительности проектах. Он легко настраивается и легко интегрируется с экосистемой npm (что неудивительно, поскольку в его состав входит официальная утилита ведения журнала npm), что делает его популярным выбором для разработчиков, которым требуется легкое решение для ведения журнала. Вот несколько причин, по которым npmlog попал в этот список:

1. Легкий. npmlog имеет небольшую кодовую базу и минимальные накладные расходы, что делает его подходящим для небольших или чувствительных к производительности проектов.
2. Простая интеграция с npm. npmlog специально разработан для использования в экосистеме npm, что упрощает интеграцию с другими пакетами и инструментами npm.
3. Настраиваемый. npmlog позволяет настраивать уровень журнала, поток и префикс, предоставляя вам полный контроль над созданием и отображением журналов.
4. Универсальность. npmlog подходит для широкого круга проектов, от небольших сценариев до крупных приложений, что делает его универсальным и гибким инструментом ведения журнала.
5. Простота использования. npmlog имеет простой API и требует минимальной настройки, что позволяет быстро и легко приступить к ведению журнала в вашем проекте Node.js.

Установка Npmlog

Чтобы установить npmlog, на вашем компьютере должны быть установлены Node.js и npm (диспетчер пакетов Node). Затем вы можете запустить следующую команду в терминале или в командной строке:

npm install npmlog

Это загрузит и установит последнюю версию npmlog и его зависимостей, что позволит вам использовать его в своем проекте Node.js.

Использование Npmlog

Вот пример использования npmlog в проекте Node.js:

const log = require('npmlog');

log.level = 'verbose';
log.verbose('This is a verbose message');
log.info('This is an informational message');
log.warn('This is a warning');
log.error('This is an error');

В этом примере мы начинаем с запроса модуля npmlog и присваиваем его переменной. Затем мы устанавливаем уровень журнала verbose, что означает, что сообщения с уровнем журнала verbose, info, warn, и будет отображаться ошибка. Затем мы регистрируем сообщения на разных уровнях, используя методы verbose, info, warn и error.

Обратите внимание, что по умолчанию npmlog пишет в process.stderr. Если вам нужно записать в process.stdout, вы можете использовать свойство log.stream.

#8. Рык

Преимущества Roarr

Библиотека roarr — это инструмент ведения журналов Node.js, предназначенный для создания структурированных данных без необходимости инициализации. Он имеет интерфейс командной строки (CLI) и поддерживает переменные среды, что делает его универсальным и простым в использовании. Кроме того, roarr совместим как со средой Node.js, так и со средой браузера, что делает его универсальным решением для ведения журналов для широкого круга приложений.

Вот несколько ключевых моментов, которые подчеркивают уникальную ценность библиотеки roarr:

1. Структурированное ведение журнала. Библиотека создает журналы в структурированном формате, что упрощает их обработку и анализ с помощью машиночитаемых инструментов.
2. Подробные метаданные. roarr предоставляет широкий набор метаданных, таких как информация о запросах и ответах, которые можно использовать для диагностики проблем и повышения общего качества ваших журналов.
3. Удобочитаемость. Несмотря на структурированный формат, журналы roarr также удобочитаемы, что упрощает понимание контекста и содержания ваших журналов.
4. Простота в использовании – библиотека предоставляет простой и интуитивно понятный API для ведения журнала без излишней сложности.
5. Настраиваемый. Библиотека roarr позволяет настраивать внешний вид и содержимое журналов, включая параметры для настройки уровня журнала, потока и метаданных.

Установка Роарра

Сначала установите roarr с помощью npm:

npm install roarr

Использование Рева

Затем импортируйте roarr в свой код и создайте регистратор:

const Roarr = require('roarr').default;
const logger = new Roarr({
context: {
service: 'my-service'
}
});

Записывать сообщения с помощью метода log:

logger.info('Hello, world!');

По умолчанию журналы roarr выводятся на консоль. Вы можете настроить вывод журнала, указав другой поток, например файл, с помощью параметра stream:

const Roarr = require('roarr').default;
const fs = require('fs');

const logger = new Roarr({
context: {
service: 'my-service'
},
stream: fs.createWriteStream('./my-service.log')
});

Это всего лишь базовый пример использования roarr. Доступно гораздо больше опций и функций, поэтому обязательно обратитесь к официальной документации roarr для получения дополнительной информации.

#9. Трейсер

Преимущества отслеживания

Tracer – это библиотека ведения журналов с открытым исходным кодом для приложений Node.js, разработанная сообществом Node.js. Он предназначен для обеспечения эффективного и гибкого способа регистрации сообщений и отладочной информации в приложениях Node.js. Tracer активно поддерживается и разрабатывается командой добровольцев и доступен для всех, кто может использовать и вносить свой вклад на Github. Вот некоторые функции, которые делают ее уникальной библиотекой ведения журналов:

1. Асинхронное ведение журнала. Tracer использует асинхронное ведение журнала, что означает, что журналы не блокируют выполнение программы.
2. Структурированное ведение журнала. Tracer обеспечивает структурированное ведение журнала, что означает, что журналы организованы в пары "ключ-значение", что упрощает поиск, анализ и визуализацию данных журнала.
3. Настраиваемый вывод. Tracer предоставляет настраиваемый формат вывода, позволяющий разработчикам выбирать формат и место назначения для своих журналов, включая консоль, файл или облачные сервисы, такие как AWS CloudWatch.
4. Расширенный контекст ведения журнала. Tracer предоставляет широкий контекст ведения журнала, включая возможность прикреплять метаданные, такие как идентификаторы запросов, идентификаторы пользователей и другую информацию, к журналам.
5. Поддержка промежуточного ПО. Tracer обеспечивает поддержку промежуточного ПО, позволяя разработчикам легко добавлять ведение журнала в свои приложения Express.js или Koa.js.

Установка трассировщика

Tracer можно установить с помощью диспетчера пакетов Node (npm). Вот шаги по установке Tracer:

1. Откройте терминал или командную строку
2. Измените текущий каталог на каталог проекта Node.js
3. Выполните следующую команду, чтобы установить Tracer:

npm install tracer

Это установит Tracer как зависимость в вашем проекте. Затем вы можете потребовать его в своем коде и начать использовать его для регистрации сообщений.

Использование трассировщика

Вот пример использования Tracer в коде:

const tracer = require('tracer');

const logger = tracer.console();

logger.info('Starting the application...');

В этом примере сначала требуется библиотека Tracer, а затем создается средство ведения журнала консоли с помощью метода tracer.console(). Наконец, мы регистрируем информационное сообщение, используя метод info объекта logger.

Вот еще один пример использования Tracer:

const tracer = require('tracer');

const logger = tracer.dailyfile({root: './logs', maxLogFiles: 10});

logger.error('An error has occurred:', new Error('Something went wrong'));

В этом примере мы используем метод tracer.dailyfile для создания регистратора файлов, который записывает журналы в ежедневно меняющийся файл. Параметр root указывает каталог, в котором будут храниться файлы журналов, а параметр maxLogFiles ограничивает количество сохраняемых файлов журналов.

Наконец, мы регистрируем сообщение об ошибке с помощью метода error в объекте регистратора вместе с объектом ошибки, предоставляя дополнительную информацию о возникшей ошибке.

#10. Сигнал

Преимущества сигнала

Его страница на Github может похвастаться тем, что ее можно «взламывать и настраивать до основания», и это основная часть того, что делает Signale такой любимой библиотекой ведения журналов в сообществе Node.js. Библиотека была создана как решение трудностей, с которыми разработчики сталкиваются при попытке вести журнал сообщений в приложениях Node.js, таких как загроможденные и трудночитаемые журналы. Вот что отличает его от остальных:

1. Настраиваемые выходные данные журнала. Signale предлагает множество настраиваемых выходных данных журнала, позволяя разработчикам выбирать вывод, который лучше всего соответствует их потребностям, от простых выходных данных консоли до более сложных выходных данных, таких как JSON и Logfmt.
2. Интуитивно понятный API. Signale имеет простой и интуитивно понятный API, который упрощает использование и понимание разработчиками даже для тех, кто плохо знаком с ведением журналов.
3. Стилизованный вывод. Signale обеспечивает стилизованный вывод, делая журналы более удобочитаемыми и визуально привлекательными, а также упрощая быстрый поиск важных сообщений журнала.
4. Расширенный контекст журнала. Signale предоставляет расширенный контекст журнала, например временные метки и уровни журнала, что упрощает анализ и понимание журналов.
5. Активное сообщество. Signale имеет большое и активное сообщество разработчиков и участников, благодаря чему библиотека хорошо поддерживается и обновляется с учетом новейших технологий и передового опыта.

Установка Signale

Чтобы установить Signale, вы можете использовать npm, диспетчер пакетов Node.js, выполнив в терминале следующую команду:

npm install signale

Кроме того, вы также можете использовать пряжу для установки Signale, выполнив следующую команду в своем терминале:

yarn add signale

После установки вы можете импортировать Signale в свое приложение Node.js и начать использовать его для регистрации сообщений и отладочной информации.

Использование Signale

Вот пример импорта Signale в ваше приложение Node.js и его использования для регистрации сообщений:

const signale = require('signale');

// Log an info message
signale.info('Starting up the server');

// Log a success message
signale.success('Server started successfully');

// Log a warning message
signale.warn('Low memory warning');

// Log an error message
signale.error(new Error('An error occurred while processing data'));

В этом примере мы импортируем Signale в наше приложение Node.js с помощью функции require. Затем мы используем различные методы регистрации, предоставляемые Signale, такие как info, success, warn и error. , для регистрации различных типов сообщений. Каждый из этих методов имеет отличительный символ и цвет, что позволяет легко определить тип сообщения журнала.

Дополнительную информацию об использовании Signale, в том числе о дополнительных методах ведения журнала и параметрах настройки, можно найти в документации по Signale.

Оптимизируйте процесс отладки с помощью библиотек журналов Node.js

Ищете быстрый и эффективный способ отладки приложений Node.js? Ознакомьтесь с одной или несколькими библиотеками, упомянутыми в этой статье, каждая из них — отличный вариант. Pino, тем не менее, является нашей личной библиотекой ведения журналов, которая того стоит 😉

Эти библиотеки ведения журналов оказались критически важными при отладке приложений Node.js как в средах тестирования/разработки, так и в рабочей среде.

Кроме того, интегрировав их с решением для мониторинга, таким как PlayerZero, вы сможете получить еще более полное представление о производительности своих приложений Node.js.

Закажите демоверсию, чтобы узнать больше о том, как PlayerZero может помочь вам оптимизировать производительность серверных приложений уже сегодня!

:::информация Также опубликовано здесь.

:::