awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
trentm avatar

trentm/node-bunyan

0
View on GitHub↗

Node Bunyan

This project is a structured logging framework and library for Node.js applications. It produces machine-readable log records in JSON format with tiered severity levels, ensuring consistent parsing and centralized storage.

The system includes a log stream manager for routing records to multiple destinations, such as files and consoles, and a command line interface for filtering, formatting, and visualizing raw JSON log streams. It supports the creation of child loggers that inherit parent configurations and merge additional contextual metadata.

The framework covers a broad range of operational capabilities, including time-based file rotation for disk management, in-memory ring buffers for post-mortem retrieval, and the exposure of internal logging events as DTrace probes for real-time runtime observation. It also provides dynamic call-site introspection to attach source location metadata to logs.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Structured JSON Loggers - Generates machine-readable log records as JSON objects to ensure consistent parsing across analysis tools.
  • Node.js Logging Libraries - A comprehensive logging framework designed specifically for the Node.js runtime environment.
  • Log Stream Routers - Routes log records to multiple destinations including files, consoles, and external data streams.
  • Inherited Logger Hierarchies - Supports child loggers that inherit parent configurations and merge additional contextual metadata.
  • Log Stream Management - Routes log data to multiple destinations and manages disk space through automatic log rotation.
  • Stream Routing - Routes log records to multiple independent writeable streams with individual severity thresholds.
  • Structured Logging Frameworks - Implements a structured logging framework that generates machine-readable logs with contextual metadata.
  • Runtime Call-Stack Capturers - Extracts filename and line number from the execution stack to provide source location metadata.
  • Runtime Debugging - Facilitates real-time process observation using DTrace probes and post-mortem analysis via ring buffers.
  • Log File Rotators - Manages disk usage by cycling log files based on defined time intervals and backup counts.
  • Ring Buffers - Maintains a fixed-size circular buffer of recent log entries for fast post-mortem retrieval.
  • Log Entry Filters - Implements predicate-based logic to filter log entries using JavaScript expressions during CLI processing.
  • Log Analysis Tools - Provides a CLI tool for filtering, formatting, and visualizing raw JSON log streams.
  • DTrace Probe Integrations - Exposes internal logging events as system probes for real-time runtime observation.
  • Application-Level Probes - Exposes internal logging events as application-level probes for real-time observation via DTrace.
  • Log Analysis - Provides a command line interface to filter, format, and visualize raw JSON log files.
  • Logging - JSON logging module.
7,212 stars·504 forks·JavaScript·19 views

Star history

Star history chart for trentm/node-bunyanStar history chart for trentm/node-bunyan

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does trentm/node-bunyan do?

This project is a structured logging framework and library for Node.js applications. It produces machine-readable log records in JSON format with tiered severity levels, ensuring consistent parsing and centralized storage.

What are the main features of trentm/node-bunyan?

The main features of trentm/node-bunyan are: Structured JSON Loggers, Node.js Logging Libraries, Log Stream Routers, Inherited Logger Hierarchies, Log Stream Management, Stream Routing, Structured Logging Frameworks, Runtime Call-Stack Capturers.

Which projects share features with trentm/node-bunyan?

Projects with overlapping indexed features include: log4js-node/log4js-node — This is a logging framework for Node.js based on the log4j architecture. It provides a system for managing… sirupsen/logrus — Logrus is a structured logging library for Go that produces machine-readable output using key-value pairs and JSON… klauscfhq/signale — Signale is a formatted console logging library for Node.js applications. It serves as a pluggable logging framework… hynek/structlog — structlog is a structured logging library for Python that treats log entries as dictionaries instead of strings. This… nodeshift/nodejs-reference-architecture — This project provides a comprehensive architectural framework and set of standardized patterns for building, securing,… rcoh/angle-grinder — Angle Grinder is a command line log processor and analytics tool used for parsing, filtering, and aggregating logs…

Projects sharing features with Node Bunyan

These projects share indexed features with Node Bunyan. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • log4js-node/log4js-nodeL

    log4js-node/log4js-node

    5,838View on GitHub↗

    This is a logging framework for Node.js based on the log4j architecture. It provides a system for managing hierarchical loggers and severity thresholds, allowing application events to be recorded and categorized across different levels of importance. The framework is distinguished by its cluster-aware logging, which synchronizes and coordinates output across multiple process clusters into a unified stream. It also includes a dedicated log file rotation manager that automatically rolls files by date or size to prevent disk space exhaustion, and a network log transporter for sending data to rem

    JavaScript
    View on GitHub↗5,838
  • sirupsen/logrussirupsen avatar

    sirupsen/logrus

    25,736View on GitHub↗

    Logrus is a structured logging library for Go that produces machine-readable output using key-value pairs and JSON formatting. It serves as a pluggable logging framework providing a thread-safe event logger with configurable mutex locking to manage concurrent writes across multiple goroutines. The project distinguishes itself through a pluggable hook system that routes log entries to external services or custom destinations. It also features a contextual logger capable of attaching persistent metadata and request-scoped fields to entries to improve traceability. The framework covers broad ob

    Gogologginglogrus
    View on GitHub↗25,736
  • klauscfhq/signaleklauscfhq avatar

    klauscfhq/signale

    9,176View on GitHub↗

    Signale is a formatted console logging library for Node.js applications. It serves as a pluggable logging framework and stream-based log router that allows users to record system events using customizable levels, colors, and output styles. The project distinguishes itself as an interactive console logger capable of overwriting previous messages to reduce terminal clutter during long-running tasks. It also functions as an application performance monitor, providing tools to measure and track execution time between specific code points to identify performance bottlenecks. The library covers a b

    JavaScript
    View on GitHub↗9,176
  • hynek/structloghynek avatar

    hynek/structlog

    4,835View on GitHub↗

    structlog is a structured logging library for Python that treats log entries as dictionaries instead of strings. This data-centric approach enables machine-readable output and precise data analysis by generating log entries as key-value pairs. It functions as both a standalone logging framework and a compatibility layer that adds structured capabilities to the Python standard library logging module. The library features a processor-pipeline architecture that passes log dictionaries through a sequence of functions to modify events or add metadata before final rendering. It includes a contextua

    Python
    View on GitHub↗4,835
Compare all 30 related projects→