Feature Request: API to check if a loglevel is enabled.

[brainkim]

LogTape provides excellent lazy evaluation for avoiding expensive computations:

logger.debug("Result: {value}", () => ({ value: expensive() }));

However, this only works for synchronous operations. For async operations, there's no way to avoid the computation:

// This always runs expensiveAsync(), even if debug is disabled
const result = await expensiveAsync();
logger.debug("Result: {result}", { result });

Proposed

Add an isEnabled(level) method to the Logger interface:

if (logger.isEnabled("debug")) {
  const result = await expensiveAsync();
  logger.debug("Result: {result}", { result });
}

Alternatively, maybe the callback API could accept async functions?

Use case

Currently I want to query logtape to determine if I should run expensive analysis (like ESBuild’s analyzeMetafile()) only when debug logging is enabled.

[dahlia]

Thanks for the feature request! I agree this is a valid use case.

I'm planning to address this with two complementary approaches:

isEnabledFor(level) method

Similar to Python's logging.Logger.isEnabledFor():

if (logger.isEnabledFor("debug")) {
  const result = await expensiveAsync();
  logger.debug("Result: {result}", { result });
}

This checks both the logger's lowestLevel and whether any sinks are configured to receive logs at that level.

Async callback support

Extending the existing lazy evaluation pattern to support async functions:

await logger.debug("Result: {value}", async () => ({
  value: await expensiveAsync()
}));

When an async callback is passed, the method returns Promise<void>. The callback is only executed if the log level is enabled.

---

Both approaches have their use cases:

• isEnabledFor() is better when you have multiple async operations or complex control flow
• Async callbacks are more concise for simple cases

I'll implement these in separate commits. Let me know if you have any feedback on this plan!

[brainkim]

Yes both APIs sound great. I’m typically a fan of one way to do things, but callback-based logging and a static isEnabledFor() API both make sense. Thanks for the prompt response! LogTape is great!

[dahlia]

Both features have been implemented and will be included in the upcoming 1.4.0 release.

Logger.isEnabledFor() method

if (logger.isEnabledFor("debug")) {
  const result = await expensiveAsync();
  logger.debug("Result: {result}", { result });
}

This method returns true if the level is at or above the logger's lowestLevel and at least one sink is configured to receive logs at that level.

Documentation: Checking if a level is enabled

Async callback support

We also implemented async callback support as you suggested:

await logger.debug("Result: {value}", async () => ({
  value: await expensiveAsync(),
}));

When you pass an async function, the logging method returns Promise<void>. The async callback is only invoked if the log level is enabled—if disabled, the callback is never called and the returned Promise resolves immediately.

Documentation: Async lazy evaluation

---

If you'd like to try these features before the official release, you can use the pre-release version 1.4.0-dev.464.

[dahlia]

Just a heads up: v1.4.0 is now being released as v2.0.0 given the scope of changes. The features mentioned above are still included!