tessl/npm-log

Universal pluggable logging utility with configurable levels and namespacing support

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Enable/Disable Control

Name: tessl/npm-log
Author: tessl

Runtime control over log visibility with restore functionality. Allows temporarily disabling logs and restoring previous state, useful for testing, debugging, and conditional logging scenarios.

Capabilities

Enable State Property

Each logger has an isEnabled property that controls whether its logs are actually output.

/**
 * Whether logger logs are exposed/visible
 * @type {boolean}
 */
log.isEnabled;

Usage Examples:

const log = require("log");

// Check current state
console.log(log.isEnabled); // true (default)

// Manually set enabled state
log.isEnabled = false;
log("This won't be logged");

log.isEnabled = true;  
log("This will be logged");

// Check namespace logger state
const appLogger = log.get("myapp");
console.log(appLogger.isEnabled); // true (inherits from parent)

Enable Method

Re-enables logging for a logger and all its namespaced children.

/**
 * Enables logger and all its namespaced children
 * @returns {RestoreObject} Object with restore() method to revert changes
 */
log.enable();

interface RestoreObject {
  /**
   * Restores the previous enabled/disabled state
   */
  restore(): void;
}

Usage Examples:

const log = require("log");

// Disable logger first
log.isEnabled = false;

// Enable with restore capability
const { restore } = log.enable();

console.log(log.isEnabled); // true
log("This will be logged");

// Restore previous state
restore();
console.log(log.isEnabled); // false

Disable Method

Disables logging for a logger and all its namespaced children.

/**
 * Disables logger and all its namespaced children  
 * @returns {RestoreObject} Object with restore() method to revert changes
 */
log.disable();

Usage Examples:

const log = require("log");

// Disable with restore capability
const { restore } = log.disable();

console.log(log.isEnabled); // false
log("This won't be logged");

// Restore previous state
restore();
console.log(log.isEnabled); // true
log("This will be logged again");

Hierarchical Control

Parent-Child Relationships

Enabling or disabling a logger affects all its namespaced children.

const log = require("log");

// Create namespaced loggers
const appLogger = log.get("myapp");
const dbLogger = appLogger.get("database"); // "myapp:database"

// Disable root logger affects all children
const { restore } = log.disable();

console.log(log.isEnabled);       // false
console.log(appLogger.isEnabled); // false  
console.log(dbLogger.isEnabled);  // false

// Restore affects all children
restore();

console.log(log.isEnabled);       // true
console.log(appLogger.isEnabled); // true
console.log(dbLogger.isEnabled);  // true

Granular Control

Individual namespace loggers can be controlled independently.

const log = require("log");

const appLogger = log.get("myapp");
const dbLogger = log.get("database");

// Disable only app logger
const { restore: restoreApp } = appLogger.disable();

console.log(log.isEnabled);       // true (root still enabled)
console.log(appLogger.isEnabled); // false
console.log(dbLogger.isEnabled);  // true (different namespace)

// App logger children are also disabled
const authLogger = appLogger.get("auth");
console.log(authLogger.isEnabled); // false

// Restore only app logger
restoreApp();
console.log(appLogger.isEnabled); // true

State Management

Multiple Disable/Enable Calls

Multiple calls to enable/disable create nested restore points.

const log = require("log");

// First disable
const { restore: restore1 } = log.disable();
console.log(log.isEnabled); // false

// Second disable (already disabled)
const { restore: restore2 } = log.disable();
console.log(log.isEnabled); // still false

// Enable while disabled
const { restore: restore3 } = log.enable();
console.log(log.isEnabled); // true

// Restore in reverse order
restore3(); // Back to disabled state from restore2
console.log(log.isEnabled); // false

restore2(); // Back to disabled state from restore1
console.log(log.isEnabled); // false

restore1(); // Back to original state
console.log(log.isEnabled); // true

Restore Object Behavior

Restore objects can only be used once and become no-ops after first use.

const log = require("log");

const { restore } = log.disable();
console.log(log.isEnabled); // false

// First restore call works
restore();
console.log(log.isEnabled); // true

// Subsequent calls are no-ops
restore(); // Does nothing
console.log(log.isEnabled); // still true

Direct Property vs Methods

Direct property assignment doesn't provide restore capability.

const log = require("log");

// Direct assignment - no restore
log.isEnabled = false;
// No way to restore previous state

// Method call - provides restore
const { restore } = log.disable();
// Can restore previous state
restore();

Use Cases

Testing Scenarios

const log = require("log");

describe("MyModule", () => {
  let restoreLog;
  
  beforeEach(() => {
    // Disable logs during tests
    restoreLog = log.disable();
  });
  
  afterEach(() => {
    // Restore logs after each test
    restoreLog.restore();
  });
  
  it("should work without log output", () => {
    // Test code here - no log output
  });
});

Conditional Logging

const log = require("log");

function debugFunction(enableDebugLogs = false) {
  const debugLogger = log.get("debug");
  
  let restore;
  if (!enableDebugLogs) {
    restore = debugLogger.disable();
  }
  
  // Function logic with debug logs
  debugLogger.info("Debug info here");
  
  // Restore if disabled
  if (restore) {
    restore.restore();
  }
}

Temporary Silence

const log = require("log");

function performQuietOperation() {
  // Temporarily disable all logging
  const { restore } = log.disable();
  
  try {
    // Perform operation that would normally log
    noisyOperation();
  } finally {
    // Always restore logging
    restore();
  }
}

Namespace-Specific Control

const log = require("log");

// Disable specific noisy components
const thirdPartyRestore = log.get("third-party").disable();
const verboseRestore = log.get("verbose-module").disable();

// Application continues with reduced log output
runApplication();

// Re-enable when needed
thirdPartyRestore.restore();
verboseRestore.restore();