@logtape/logtape 1.4.0-dev.409 → 1.4.0-dev.413

package/src/context.test.ts

@@ -1,341 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assertEquals } from "@std/assert/equals";
-import { delay } from "@std/async/delay";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { configure, reset } from "./config.ts";
-import { withCategoryPrefix, withContext } from "./context.ts";
-import { getLogger } from "./logger.ts";
-import type { LogRecord } from "./record.ts";
-
-const test = suite(import.meta);
-
-test("withContext()", async () => {
-  const buffer: LogRecord[] = [];
-
-  { // set up
-    await configure({
-      sinks: {
-        buffer: buffer.push.bind(buffer),
-      },
-      loggers: [
-        { category: "my-app", sinks: ["buffer"], lowestLevel: "debug" },
-        { category: ["logtape", "meta"], sinks: [], lowestLevel: "warning" },
-      ],
-      contextLocalStorage: new AsyncLocalStorage(),
-      reset: true,
-    });
-  }
-
-  try {
-    // test
-    getLogger("my-app").debug("hello", { foo: 1, bar: 2 });
-    assertEquals(buffer, [
-      {
-        category: ["my-app"],
-        level: "debug",
-        message: ["hello"],
-        rawMessage: "hello",
-        properties: { foo: 1, bar: 2 },
-        timestamp: buffer[0].timestamp,
-      },
-    ]);
-    buffer.pop();
-    const rv = withContext({ foo: 3, baz: 4 }, () => {
-      getLogger("my-app").debug("world", { foo: 1, bar: 2 });
-      return 123;
-    });
-    assertEquals(rv, 123);
-    assertEquals(buffer, [
-      {
-        category: ["my-app"],
-        level: "debug",
-        message: ["world"],
-        rawMessage: "world",
-        properties: { foo: 1, bar: 2, baz: 4 },
-        timestamp: buffer[0].timestamp,
-      },
-    ]);
-    buffer.pop();
-    getLogger("my-app").debug("hello", { foo: 1, bar: 2 });
-    assertEquals(buffer, [
-      {
-        category: ["my-app"],
-        level: "debug",
-        message: ["hello"],
-        rawMessage: "hello",
-        properties: { foo: 1, bar: 2 },
-        timestamp: buffer[0].timestamp,
-      },
-    ]);
-
-    // nesting
-    while (buffer.length > 0) buffer.pop();
-    withContext({ foo: 1, bar: 2 }, () => {
-      withContext({ foo: 3, baz: 4 }, () => {
-        getLogger("my-app").debug("hello");
-      });
-    });
-    assertEquals(buffer, [
-      {
-        category: ["my-app"],
-        level: "debug",
-        message: ["hello"],
-        rawMessage: "hello",
-        properties: { foo: 3, bar: 2, baz: 4 },
-        timestamp: buffer[0].timestamp,
-      },
-    ]);
-
-    // concurrent runs
-    while (buffer.length > 0) buffer.pop();
-    await Promise.all([
-      (async () => {
-        await delay(Math.random() * 100);
-        withContext({ foo: 1 }, () => {
-          getLogger("my-app").debug("foo");
-        });
-      })(),
-      (async () => {
-        await delay(Math.random() * 100);
-        withContext({ bar: 2 }, () => {
-          getLogger("my-app").debug("bar");
-        });
-      })(),
-      (async () => {
-        await delay(Math.random() * 100);
-        withContext({ baz: 3 }, () => {
-          getLogger("my-app").debug("baz");
-        });
-      })(),
-      (async () => {
-        await delay(Math.random() * 100);
-        withContext({ qux: 4 }, () => {
-          getLogger("my-app").debug("qux");
-        });
-      })(),
-    ]);
-    assertEquals(buffer.length, 4);
-    for (const log of buffer) {
-      if (log.message[0] === "foo") {
-        assertEquals(log.properties, { foo: 1 });
-      } else if (log.message[0] === "bar") {
-        assertEquals(log.properties, { bar: 2 });
-      } else if (log.message[0] === "baz") {
-        assertEquals(log.properties, { baz: 3 });
-      } else {
-        assertEquals(log.properties, { qux: 4 });
-      }
-    }
-  } finally {
-    await reset();
-  }
-
-  const metaBuffer: LogRecord[] = [];
-
-  { // set up
-    await configure({
-      sinks: {
-        buffer: buffer.push.bind(buffer),
-        metaBuffer: metaBuffer.push.bind(metaBuffer),
-      },
-      loggers: [
-        { category: "my-app", sinks: ["buffer"], lowestLevel: "debug" },
-        {
-          category: ["logtape", "meta"],
-          sinks: ["metaBuffer"],
-          lowestLevel: "warning",
-        },
-      ],
-      reset: true,
-    });
-  }
-
-  try { // without settings
-    while (buffer.length > 0) buffer.pop();
-    const rv = withContext({ foo: 1 }, () => {
-      getLogger("my-app").debug("hello", { bar: 2 });
-      return 123;
-    });
-    assertEquals(rv, 123);
-    assertEquals(buffer, [
-      {
-        category: ["my-app"],
-        level: "debug",
-        message: ["hello"],
-        rawMessage: "hello",
-        properties: { bar: 2 },
-        timestamp: buffer[0].timestamp,
-      },
-    ]);
-    assertEquals(metaBuffer, [
-      {
-        category: ["logtape", "meta"],
-        level: "warning",
-        message: [
-          "Context-local storage is not configured.  " +
-          "Specify contextLocalStorage option in the configure() function.",
-        ],
-        properties: {},
-        rawMessage: "Context-local storage is not configured.  " +
-          "Specify contextLocalStorage option in the configure() function.",
-        timestamp: metaBuffer[0].timestamp,
-      },
-    ]);
-  } finally {
-    await reset();
-  }
-});
-
-test("withCategoryPrefix()", async () => {
-  const buffer: LogRecord[] = [];
-
-  { // set up
-    await configure({
-      sinks: {
-        buffer: buffer.push.bind(buffer),
-      },
-      loggers: [
-        { category: [], sinks: ["buffer"], lowestLevel: "debug" },
-        { category: ["logtape", "meta"], sinks: [], lowestLevel: "warning" },
-      ],
-      contextLocalStorage: new AsyncLocalStorage(),
-      reset: true,
-    });
-  }
-
-  try {
-    // basic prefix with array
-    getLogger(["core-lib"]).debug("without prefix");
-    assertEquals(buffer[0].category, ["core-lib"]);
-    buffer.pop();
-
-    const rv = withCategoryPrefix(["sdk-1"], () => {
-      getLogger(["core-lib"]).debug("with prefix");
-      return 123;
-    });
-    assertEquals(rv, 123);
-    assertEquals(buffer[0].category, ["sdk-1", "core-lib"]);
-    buffer.pop();
-
-    // prefix should not persist after callback
-    getLogger(["core-lib"]).debug("after prefix");
-    assertEquals(buffer[0].category, ["core-lib"]);
-    buffer.pop();
-
-    // basic prefix with string
-    withCategoryPrefix("sdk-2", () => {
-      getLogger(["core-lib"]).debug("string prefix");
-    });
-    assertEquals(buffer[0].category, ["sdk-2", "core-lib"]);
-    buffer.pop();
-
-    // nesting prefixes
-    withCategoryPrefix(["app"], () => {
-      withCategoryPrefix(["sdk-1"], () => {
-        getLogger(["core-lib"]).debug("nested");
-      });
-    });
-    assertEquals(buffer[0].category, ["app", "sdk-1", "core-lib"]);
-    buffer.pop();
-
-    // combining with withContext
-    withCategoryPrefix(["my-sdk"], () => {
-      withContext({ requestId: "abc-123" }, () => {
-        getLogger(["internal"]).debug("combined");
-      });
-    });
-    assertEquals(buffer[0].category, ["my-sdk", "internal"]);
-    assertEquals(buffer[0].properties, { requestId: "abc-123" });
-    buffer.pop();
-
-    // withContext inside withCategoryPrefix
-    withContext({ userId: 42 }, () => {
-      withCategoryPrefix(["sdk"], () => {
-        getLogger(["lib"]).debug("context then prefix");
-      });
-    });
-    assertEquals(buffer[0].category, ["sdk", "lib"]);
-    assertEquals(buffer[0].properties, { userId: 42 });
-    buffer.pop();
-
-    // concurrent runs - each should have isolated prefix
-    await Promise.all([
-      (async () => {
-        await delay(Math.random() * 100);
-        withCategoryPrefix(["sdk-a"], () => {
-          getLogger(["lib"]).debug("a");
-        });
-      })(),
-      (async () => {
-        await delay(Math.random() * 100);
-        withCategoryPrefix(["sdk-b"], () => {
-          getLogger(["lib"]).debug("b");
-        });
-      })(),
-      (async () => {
-        await delay(Math.random() * 100);
-        withCategoryPrefix(["sdk-c"], () => {
-          getLogger(["lib"]).debug("c");
-        });
-      })(),
-      (async () => {
-        await delay(Math.random() * 100);
-        withCategoryPrefix(["sdk-d"], () => {
-          getLogger(["lib"]).debug("d");
-        });
-      })(),
-    ]);
-    assertEquals(buffer.length, 4);
-    for (const log of buffer) {
-      if (log.message[0] === "a") {
-        assertEquals(log.category, ["sdk-a", "lib"]);
-      } else if (log.message[0] === "b") {
-        assertEquals(log.category, ["sdk-b", "lib"]);
-      } else if (log.message[0] === "c") {
-        assertEquals(log.category, ["sdk-c", "lib"]);
-      } else {
-        assertEquals(log.category, ["sdk-d", "lib"]);
-      }
-    }
-  } finally {
-    await reset();
-  }
-
-  // without contextLocalStorage configured
-  const metaBuffer: LogRecord[] = [];
-
-  { // set up
-    await configure({
-      sinks: {
-        buffer: buffer.push.bind(buffer),
-        metaBuffer: metaBuffer.push.bind(metaBuffer),
-      },
-      loggers: [
-        { category: "my-app", sinks: ["buffer"], lowestLevel: "debug" },
-        {
-          category: ["logtape", "meta"],
-          sinks: ["metaBuffer"],
-          lowestLevel: "warning",
-        },
-      ],
-      reset: true,
-    });
-  }
-
-  try {
-    while (buffer.length > 0) buffer.pop();
-    const rv = withCategoryPrefix(["sdk-1"], () => {
-      getLogger(["my-app"]).debug("no storage");
-      return 456;
-    });
-    assertEquals(rv, 456);
-    // Without storage, category should not have prefix
-    assertEquals(buffer[0].category, ["my-app"]);
-    // Warning should be logged to meta logger
-    assertEquals(metaBuffer.length, 1);
-    assertEquals(metaBuffer[0].category, ["logtape", "meta"]);
-    assertEquals(metaBuffer[0].level, "warning");
-  } finally {
-    await reset();
-  }
-});

package/src/context.ts

@@ -1,150 +0,0 @@
-import { LoggerImpl } from "./logger.ts";
-
-/**
- * Internal symbol for storing category prefix in context.
- */
-const categoryPrefixSymbol: unique symbol = Symbol.for(
-  "logtape.categoryPrefix",
-) as typeof categoryPrefixSymbol;
-
-/**
- * A generic interface for a context-local storage.  It resembles
- * the {@link AsyncLocalStorage} API from Node.js.
- * @template T The type of the context-local store.
- * @since 0.7.0
- */
-export interface ContextLocalStorage<T> {
-  /**
-   * Runs a callback with the given store as the context-local store.
-   * @param store The store to use as the context-local store.
-   * @param callback The callback to run.
-   * @returns The return value of the callback.
-   */
-  run<R>(store: T, callback: () => R): R;
-
-  /**
-   * Returns the current context-local store.
-   * @returns The current context-local store, or `undefined` if there is no
-   *          store.
-   */
-  getStore(): T | undefined;
-}
-
-/**
- * Runs a callback with the given implicit context.  Every single log record
- * in the callback will have the given context.
- *
- * If no `contextLocalStorage` is configured, this function does nothing and
- * just returns the return value of the callback.  It also logs a warning to
- * the `["logtape", "meta"]` logger in this case.
- * @param context The context to inject.
- * @param callback The callback to run.
- * @returns The return value of the callback.
- * @since 0.7.0
- */
-export function withContext<T>(
-  context: Record<string, unknown>,
-  callback: () => T,
-): T {
-  const rootLogger = LoggerImpl.getLogger();
-  if (rootLogger.contextLocalStorage == null) {
-    LoggerImpl.getLogger(["logtape", "meta"]).warn(
-      "Context-local storage is not configured.  " +
-        "Specify contextLocalStorage option in the configure() function.",
-    );
-    return callback();
-  }
-  const parentContext = rootLogger.contextLocalStorage.getStore() ?? {};
-  return rootLogger.contextLocalStorage.run(
-    { ...parentContext, ...context },
-    callback,
-  );
-}
-
-/**
- * Gets the current category prefix from context local storage.
- * @returns The current category prefix, or an empty array if not set.
- * @since 1.3.0
- */
-export function getCategoryPrefix(): readonly string[] {
-  const rootLogger = LoggerImpl.getLogger();
-  const store = rootLogger.contextLocalStorage?.getStore();
-  if (store == null) return [];
-  const prefix = store[categoryPrefixSymbol as unknown as string];
-  return Array.isArray(prefix) ? prefix : [];
-}
-
-/**
- * Gets the current implicit context from context local storage, excluding
- * internal symbol keys (like category prefix).
- * @returns The current implicit context without internal symbol keys.
- * @since 1.3.0
- */
-export function getImplicitContext(): Record<string, unknown> {
-  const rootLogger = LoggerImpl.getLogger();
-  const store = rootLogger.contextLocalStorage?.getStore();
-  if (store == null) return {};
-  // Filter out symbol keys (like categoryPrefixSymbol)
-  const result: Record<string, unknown> = {};
-  for (const key of Object.keys(store)) {
-    result[key] = store[key];
-  }
-  return result;
-}
-
-/**
- * Runs a callback with the given category prefix prepended to all log
- * categories within the callback context.
- *
- * This is useful for SDKs or libraries that want to add their own category
- * as a prefix to logs from their internal dependencies.
- *
- * If no `contextLocalStorage` is configured, this function does nothing and
- * just returns the return value of the callback.  It also logs a warning to
- * the `["logtape", "meta"]` logger in this case.
- *
- * @example Basic usage
- * ```typescript
- * import { getLogger, withCategoryPrefix } from "@logtape/logtape";
- *
- * export function sdkFunction() {
- *   return withCategoryPrefix(["my-sdk"], () => {
- *     // Any logs from internal libraries within this context
- *     // will have ["my-sdk"] prepended to their category
- *     return internalLibraryFunction();
- *   });
- * }
- * ```
- *
- * @param prefix The category prefix to prepend.  Can be a string or an array
- *               of strings.
- * @param callback The callback to run.
- * @returns The return value of the callback.
- * @since 1.3.0
- */
-export function withCategoryPrefix<T>(
-  prefix: string | readonly string[],
-  callback: () => T,
-): T {
-  const rootLogger = LoggerImpl.getLogger();
-  if (rootLogger.contextLocalStorage == null) {
-    LoggerImpl.getLogger(["logtape", "meta"]).warn(
-      "Context-local storage is not configured.  " +
-        "Specify contextLocalStorage option in the configure() function.",
-    );
-    return callback();
-  }
-  const parentContext = rootLogger.contextLocalStorage.getStore() ?? {};
-  const parentPrefix = getCategoryPrefix();
-  const newPrefix = typeof prefix === "string" ? [prefix] : [...prefix];
-  return rootLogger.contextLocalStorage.run(
-    {
-      ...parentContext,
-      [categoryPrefixSymbol as unknown as string]: [
-        ...parentPrefix,
-        ...newPrefix,
-      ],
-    },
-    callback,
-  );
-}

package/src/filter.test.ts

@@ -1,84 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assert } from "@std/assert/assert";
-import { assertFalse } from "@std/assert/false";
-import { assertStrictEquals } from "@std/assert/strict-equals";
-import { assertThrows } from "@std/assert/throws";
-import { type Filter, getLevelFilter, toFilter } from "./filter.ts";
-import { debug, error, fatal, info, trace, warning } from "./fixtures.ts";
-import type { LogLevel } from "./level.ts";
-
-const test = suite(import.meta);
-
-test("getLevelFilter()", () => {
-  const noneFilter = getLevelFilter(null);
-  assertFalse(noneFilter(fatal));
-  assertFalse(noneFilter(error));
-  assertFalse(noneFilter(warning));
-  assertFalse(noneFilter(info));
-  assertFalse(noneFilter(debug));
-  assertFalse(noneFilter(trace));
-
-  const fatalFilter = getLevelFilter("fatal");
-  assert(fatalFilter(fatal));
-  assertFalse(fatalFilter(error));
-  assertFalse(fatalFilter(warning));
-  assertFalse(fatalFilter(info));
-  assertFalse(fatalFilter(debug));
-  assertFalse(fatalFilter(trace));
-
-  const errorFilter = getLevelFilter("error");
-  assert(errorFilter(fatal));
-  assert(errorFilter(error));
-  assertFalse(errorFilter(warning));
-  assertFalse(errorFilter(info));
-  assertFalse(errorFilter(debug));
-  assertFalse(errorFilter(trace));
-
-  const warningFilter = getLevelFilter("warning");
-  assert(warningFilter(fatal));
-  assert(warningFilter(error));
-  assert(warningFilter(warning));
-  assertFalse(warningFilter(info));
-  assertFalse(warningFilter(debug));
-  assertFalse(warningFilter(trace));
-
-  const infoFilter = getLevelFilter("info");
-  assert(infoFilter(fatal));
-  assert(infoFilter(error));
-  assert(infoFilter(warning));
-  assert(infoFilter(info));
-  assertFalse(infoFilter(debug));
-  assertFalse(infoFilter(trace));
-
-  const debugFilter = getLevelFilter("debug");
-  assert(debugFilter(fatal));
-  assert(debugFilter(error));
-  assert(debugFilter(warning));
-  assert(debugFilter(info));
-  assert(debugFilter(debug));
-  assertFalse(debugFilter(trace));
-
-  const traceFilter = getLevelFilter("trace");
-  assert(traceFilter(fatal));
-  assert(traceFilter(error));
-  assert(traceFilter(warning));
-  assert(traceFilter(info));
-  assert(traceFilter(debug));
-  assert(traceFilter(trace));
-
-  assertThrows(
-    () => getLevelFilter("invalid" as LogLevel),
-    TypeError,
-    "Invalid log level: invalid.",
-  );
-});
-
-test("toFilter()", () => {
-  const hasJunk: Filter = (record) => record.category.includes("junk");
-  assertStrictEquals(toFilter(hasJunk), hasJunk);
-
-  const infoFilter = toFilter("info");
-  assertFalse(infoFilter(debug));
-  assert(infoFilter(info));
-  assert(infoFilter(warning));
-});

package/src/filter.ts

@@ -1,64 +0,0 @@
-import type { LogLevel } from "./level.ts";
-import type { LogRecord } from "./record.ts";
-
-/**
- * A filter is a function that accepts a log record and returns `true` if the
- * record should be passed to the sink.
- *
- * @param record The log record to filter.
- * @returns `true` if the record should be passed to the sink.
- */
-export type Filter = (record: LogRecord) => boolean;
-
-/**
- * A filter-like value is either a {@link Filter} or a {@link LogLevel}.
- * `null` is also allowed to represent a filter that rejects all records.
- */
-export type FilterLike = Filter | LogLevel | null;
-
-/**
- * Converts a {@link FilterLike} value to an actual {@link Filter}.
- *
- * @param filter The filter-like value to convert.
- * @returns The actual filter.
- */
-export function toFilter(filter: FilterLike): Filter {
-  if (typeof filter === "function") return filter;
-  return getLevelFilter(filter);
-}
-
-/**
- * Returns a filter that accepts log records with the specified level.
- *
- * @param level The level to filter by.  If `null`, the filter will reject all
- *              records.
- * @returns The filter.
- */
-export function getLevelFilter(level: LogLevel | null): Filter {
-  if (level == null) return () => false;
-  if (level === "fatal") {
-    return (record: LogRecord) => record.level === "fatal";
-  } else if (level === "error") {
-    return (record: LogRecord) =>
-      record.level === "fatal" || record.level === "error";
-  } else if (level === "warning") {
-    return (record: LogRecord) =>
-      record.level === "fatal" ||
-      record.level === "error" ||
-      record.level === "warning";
-  } else if (level === "info") {
-    return (record: LogRecord) =>
-      record.level === "fatal" ||
-      record.level === "error" ||
-      record.level === "warning" ||
-      record.level === "info";
-  } else if (level === "debug") {
-    return (record: LogRecord) =>
-      record.level === "fatal" ||
-      record.level === "error" ||
-      record.level === "warning" ||
-      record.level === "info" ||
-      record.level === "debug";
-  } else if (level === "trace") return () => true;
-  throw new TypeError(`Invalid log level: ${level}.`);
-}

package/src/fixtures.ts

@@ -1,35 +0,0 @@
-import type { LogRecord } from "./record.ts";
-
-export const info: LogRecord = {
-  level: "info",
-  category: ["my-app", "junk"],
-  message: ["Hello, ", 123, " & ", 456, "!"],
-  rawMessage: "Hello, {a} & {b}!",
-  timestamp: 1700000000000,
-  properties: {},
-};
-
-export const trace: LogRecord = {
-  ...info,
-  level: "trace",
-};
-
-export const debug: LogRecord = {
-  ...info,
-  level: "debug",
-};
-
-export const warning: LogRecord = {
-  ...info,
-  level: "warning",
-};
-
-export const error: LogRecord = {
-  ...info,
-  level: "error",
-};
-
-export const fatal: LogRecord = {
-  ...info,
-  level: "fatal",
-};