@vscode-logging/logger

This logger integrates cleanly with VSCode's output channels and provides structured logging without requiring external dependencies. The API is straightforward - you create a logger instance tied to an extension context and it handles log levels, formatting, and output routing. From a security perspective, it's refreshingly minimal with zero transitive dependencies, eliminating supply chain concerns that plague heavier logging frameworks.

The library doesn't handle sensitive data masking automatically, so you need to be careful about what you pass to log methods - it will happily output authentication tokens or API keys if you're not careful with structured parameters. Error stack traces are logged verbatim, which is useful for debugging but requires deliberate sanitization in production scenarios. The lack of built-in PII filtering means you're responsible for implementing your own safeguards.

Input validation is basic but adequate - the logger won't crash on null/undefined but also doesn't enforce type safety strictly. The Apache 2.0 license is permissive and well-understood. For VSCode extension development specifically, this is a practical choice that avoids bloat while providing necessary functionality.

After using this in multiple VSCode extensions, it's become my go-to logging solution for that specific environment. The library provides a clean wrapper around VSCode's OutputChannel API with structured logging capabilities. Setup is straightforward - you instantiate a logger with a channel name and start logging. The API surface is intentionally small with standard log levels (trace, debug, info, warn, error, fatal) that map well to VSCode's output panel.

The library shines in production use with its log source tracking feature that automatically captures file/line information, making debugging extension issues much easier. Memory footprint is negligible, and there's no observable performance impact even with verbose logging enabled. The lazy initialization pattern means channels aren't created until first use, which is good for resource management.

One gotcha: the breaking change from 1.x to 2.x altered the initialization API, requiring migration work. The library lacks built-in log rotation or filtering mechanisms beyond level control, so you're relying on VSCode's output channel behavior. For extensions with heavy logging needs, you'll want to implement your own throttling. Overall, it does exactly what it promises without overengineering.

This package does exactly what it says with a clean API that feels natural for VSCode extension development. Getting started is straightforward—you create a logger instance with `getExtensionLogger()`, pass your extension context, and you're logging. The library handles output channels automatically and integrates seamlessly with VSCode's logging infrastructure. The main API surface is small enough to learn in minutes.

The real value shows up during debugging. Log levels work as expected (trace, debug, info, warn, error, fatal), and logs appear in VSCode's Output panel exactly where users expect them. Child loggers are useful for namespacing different parts of your extension. Error messages are clear when you misconfigure something, like forgetting to initialize the logger.

Documentation is functional but minimal—mostly README-based with code examples. The GitHub repo has reasonable issue response times. For such a focused package, the lack of extensive tutorials isn't a dealbreaker since the API is intuitive. One gotcha: you need to understand VSCode's extension context lifecycle to avoid initialization timing issues.