Retain overlapping scoped resources

Track active scoped configurations so scope disposal can retain disposable
sinks and filters still owned by another live scope.  This prevents
concurrent or overlapping scopes that share a resource from closing it while
another scope can still route logs to it.

Prefer Symbol.asyncDispose over Symbol.dispose when a scoped sink or filter
implements both disposal protocols, matching async resource ownership with a
single cleanup path.

#188 (comment)
#188 (comment)
#188 (comment)

Assisted-by: Codex:gpt-5.5

Author: dahlia

packages/logtape/src/config.test.ts

@@ -803,6 +803,41 @@ test("withConfig() disposes scoped resources when the scope exits", async () =>
   }
 });
 
+test("withConfig() prefers async disposal for dual disposable resources", async () => {
+  const events: string[] = [];
+  const sink: Sink & Disposable & AsyncDisposable = () => {};
+  sink[Symbol.dispose] = () => events.push("sync sink");
+  sink[Symbol.asyncDispose] = async () => {
+    await Promise.resolve();
+    events.push("async sink");
+  };
+  const filter: Filter & Disposable & AsyncDisposable = () => true;
+  filter[Symbol.dispose] = () => events.push("sync filter");
+  filter[Symbol.asyncDispose] = async () => {
+    await Promise.resolve();
+    events.push("async filter");
+  };
+
+  await configure({
+    sinks: {},
+    loggers: [{ category: ["logtape", "meta"], sinks: [] }],
+    contextLocalStorage: new AsyncLocalStorage(),
+    reset: true,
+  });
+
+  try {
+    await withConfig({
+      sinks: { sink },
+      filters: { filter },
+      loggers: [{ category: "app", sinks: ["sink"], filters: ["filter"] }],
+    }, () => {});
+
+    assert.deepStrictEqual(events, ["async filter", "async sink"]);
+  } finally {
+    await reset();
+  }
+});
+
 test("withConfig() does not dispose resources still owned by parent scopes", async () => {
   const records: LogRecord[] = [];
   const events: string[] = [];
@@ -852,6 +887,70 @@ test("withConfig() does not dispose resources still owned by parent scopes", asy
   }
 });
 
+test("withConfig() does not dispose resources still owned by sibling scopes", async () => {
+  const records: LogRecord[] = [];
+  const events: string[] = [];
+  const sharedSink: Sink & Disposable = (record) => {
+    records.push(record);
+  };
+  sharedSink[Symbol.dispose] = () => events.push("sink");
+  const sharedFilter: Filter & Disposable = () => true;
+  sharedFilter[Symbol.dispose] = () => events.push("filter");
+
+  await configure({
+    sinks: {},
+    loggers: [{ category: ["logtape", "meta"], sinks: [] }],
+    contextLocalStorage: new AsyncLocalStorage(),
+    reset: true,
+  });
+
+  try {
+    let finishFirst!: () => void;
+    let markSecondEntered!: () => void;
+    const releaseFirst = new Promise<void>((resolve) => {
+      finishFirst = resolve;
+    });
+    const secondEntered = new Promise<void>((resolve) => {
+      markSecondEntered = resolve;
+    });
+    const firstDone = withConfig({
+      sinks: { shared: sharedSink },
+      filters: { shared: sharedFilter },
+      loggers: [
+        { category: "app", filters: ["shared"], sinks: ["shared"] },
+      ],
+    }, async () => {
+      await secondEntered;
+      await releaseFirst;
+      getLogger("app").info("first");
+    });
+    const secondDone = withConfig({
+      sinks: { shared: sharedSink },
+      filters: { shared: sharedFilter },
+      loggers: [
+        { category: "app", filters: ["shared"], sinks: ["shared"] },
+      ],
+    }, () => {
+      markSecondEntered();
+      assert.deepStrictEqual(events, []);
+      getLogger("app").info("second");
+    });
+
+    await secondDone;
+    assert.deepStrictEqual(events, []);
+    finishFirst();
+    await firstDone;
+
+    assert.deepStrictEqual(events, ["filter", "sink"]);
+    assert.deepStrictEqual(
+      records.map((record) => record.rawMessage).sort(),
+      ["first", "second"],
+    );
+  } finally {
+    await reset();
+  }
+});
+
 test("withConfig() does not dispose resources still owned globally", async () => {
   const records: LogRecord[] = [];
   const events: string[] = [];

packages/logtape/src/config.ts

@@ -3,6 +3,7 @@ import { type FilterLike, toFilter } from "./filter.ts";
 import type { LogLevel } from "./level.ts";
 import { LoggerImpl } from "./logger.ts";
 import {
+  type CompiledScopedConfig,
   compileScopedConfig,
   disposeScopedConfig,
   disposeScopedConfigSync,
@@ -107,6 +108,7 @@ export interface LoggerConfig<
  */
 let currentConfig: Config<string, string> | null = null;
 let activeScopedConfigCount = 0;
+const activeScopedConfigs: Set<CompiledScopedConfig> = new Set();
 let globalConfigMutationInProgress = false;
 
 /**
@@ -339,6 +341,7 @@ export async function withConfig<
   let callbackError: unknown;
   let callbackFailed = false;
   activeScopedConfigCount++;
+  activeScopedConfigs.add(scopedConfig);
   try {
     result = await runWithScopedConfig(
       contextLocalStorage,
@@ -351,13 +354,17 @@ export async function withConfig<
   }
 
   try {
-    await disposeScopedConfig(scopedConfig, getGlobalDisposables());
+    await disposeScopedConfig(
+      scopedConfig,
+      getRetainedDisposables(scopedConfig),
+    );
   } catch (disposeError) {
     if (callbackFailed) {
       throwCombinedErrors(callbackError, disposeError);
     }
     throw disposeError;
   } finally {
+    activeScopedConfigs.delete(scopedConfig);
     activeScopedConfigCount--;
   }
 
@@ -397,6 +404,7 @@ export function withConfigSync<
   let callbackError: unknown;
   let callbackFailed = false;
   activeScopedConfigCount++;
+  activeScopedConfigs.add(scopedConfig);
   try {
     result = runWithScopedConfig(contextLocalStorage, scopedConfig, callback);
     if (isThenable(result)) {
@@ -413,13 +421,14 @@ export function withConfigSync<
   }
 
   try {
-    disposeScopedConfigSync(scopedConfig, getGlobalDisposables());
+    disposeScopedConfigSync(scopedConfig, getRetainedDisposables(scopedConfig));
   } catch (disposeError) {
     if (callbackFailed) {
       throwCombinedErrors(callbackError, disposeError);
     }
     throw disposeError;
   } finally {
+    activeScopedConfigs.delete(scopedConfig);
     activeScopedConfigCount--;
   }
 
@@ -443,6 +452,33 @@ function getGlobalDisposables(): ReadonlySet<Disposable | AsyncDisposable> {
   ]);
 }
 
+function getRetainedDisposables(
+  scopedConfig: CompiledScopedConfig,
+): ReadonlySet<Disposable | AsyncDisposable> {
+  const disposables = new Set<Disposable | AsyncDisposable>(
+    getGlobalDisposables(),
+  );
+  for (const activeScopedConfig of activeScopedConfigs) {
+    if (activeScopedConfig === scopedConfig) continue;
+    addScopedConfigDisposables(disposables, activeScopedConfig);
+  }
+  return disposables;
+}
+
+function addScopedConfigDisposables(
+  disposables: Set<Disposable | AsyncDisposable>,
+  scopedConfig: CompiledScopedConfig,
+): void {
+  for (const disposable of scopedConfig.syncFilters) {
+    disposables.add(disposable);
+  }
+  for (const disposable of scopedConfig.asyncFilters) {
+    disposables.add(disposable);
+  }
+  for (const disposable of scopedConfig.syncSinks) disposables.add(disposable);
+  for (const disposable of scopedConfig.asyncSinks) disposables.add(disposable);
+}
+
 function configureInternal<
   TSinkId extends string,
   TFilterId extends string,

packages/logtape/src/scoped-config.ts

@@ -141,8 +141,7 @@ export function compileScopedConfig<
         );
       }
       asyncSinks.add(sink as AsyncDisposable);
-    }
-    if (Symbol.dispose in sink) syncSinks.add(sink as Disposable);
+    } else if (Symbol.dispose in sink) syncSinks.add(sink as Disposable);
   }
 
   for (const filter of Object.values<FilterLike>(config.filters ?? {})) {
@@ -155,8 +154,7 @@ export function compileScopedConfig<
       }
       asyncFilters.add(filter as AsyncDisposable);
       asyncSinks.delete(filter as AsyncDisposable);
-    }
-    if (Symbol.dispose in filter) {
+    } else if (Symbol.dispose in filter) {
       syncFilters.add(filter as Disposable);
       syncSinks.delete(filter as Disposable);
     }