From 9d37f3819269f858df2dec7c9293f26868620c32 Mon Sep 17 00:00:00 2001 From: isaacs Date: Tue, 21 Jul 2026 11:25:48 -0700 Subject: [PATCH] feat(deno): add lruMemoizer integration --- .../suites/orchestrion-lru-memoizer/test.ts | 124 ++++++++++++++++++ packages/deno/src/index.ts | 1 + packages/deno/src/sdk.ts | 2 + .../deno/test/__snapshots__/mod.test.ts.snap | 4 + 4 files changed, 131 insertions(+) create mode 100644 dev-packages/deno-integration-tests/suites/orchestrion-lru-memoizer/test.ts diff --git a/dev-packages/deno-integration-tests/suites/orchestrion-lru-memoizer/test.ts b/dev-packages/deno-integration-tests/suites/orchestrion-lru-memoizer/test.ts new file mode 100644 index 000000000000..4cbdc3179943 --- /dev/null +++ b/dev-packages/deno-integration-tests/suites/orchestrion-lru-memoizer/test.ts @@ -0,0 +1,124 @@ +// + +import { tracingChannel } from 'node:diagnostics_channel'; +import type { Span, TransactionEvent } from '@sentry/core'; +import type { DenoClient } from '@sentry/deno'; +import { + getActiveSpan, + getCurrentScope, + getGlobalScope, + getIsolationScope, + init, + startSpan, + startSpanManual, +} from '@sentry/deno'; +import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts'; +import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.ts'; +import { assertExists } from 'https://deno.land/std@0.212.0/assert/assert_exists.ts'; + +function resetGlobals(): void { + getCurrentScope().clear(); + getCurrentScope().setClient(undefined); + getIsolationScope().clear(); + getGlobalScope().clear(); +} + +/** See deno-redis.test.ts — same sink shape, deduped for clarity. */ +function transactionSink(): { + beforeSendTransaction: (event: TransactionEvent) => null; + waitFor: (predicate: (event: TransactionEvent) => boolean) => Promise; +} { + const transactions: TransactionEvent[] = []; + const waiters: { predicate: (e: TransactionEvent) => boolean; resolve: (e: TransactionEvent) => void }[] = []; + return { + beforeSendTransaction(event) { + transactions.push(event); + for (let i = waiters.length - 1; i >= 0; i--) { + const w = waiters[i]!; + if (w.predicate(event)) { + waiters.splice(i, 1); + w.resolve(event); + } + } + return null; + }, + waitFor(predicate) { + const already = transactions.find(predicate); + if (already) return Promise.resolve(already); + return new Promise(resolve => { + waiters.push({ predicate, resolve }); + }); + }, + }; +} + +function withTimeout(p: Promise, ms: number, what: string): Promise { + let timer: ReturnType | undefined; + const timeout = new Promise((_, reject) => { + timer = setTimeout(() => reject(new Error(`Timed out waiting for ${what} after ${ms}ms`)), ms); + }); + return Promise.race([p, timeout]).finally(() => { + if (timer !== undefined) clearTimeout(timer); + }); +} + +Deno.test('lru-memoizer instrumentation: included in default integrations (Deno 2.8.0+)', () => { + resetGlobals(); + const client = init({ dsn: 'https://username@domain/123' }) as DenoClient; + const names = client.getOptions().integrations.map(i => i.name); + assert(names.includes('LruMemoizer'), `LruMemoizer should be in defaults, got ${names.join(', ')}`); +}); + +// lru-memoizer creates no span of its own; it restores the caller's scope onto +// the memoized callback (which it fires from a detached `setImmediate`). We drive +// `start` while a parent span is active (capturing the caller's context), then +// drive `asyncStart` from a detached context where that span is NOT active — as +// happens when the callback fires later. Without the restore, work there starts a +// new trace; with it, the parent is active again and a span nests under it. +Deno.test('lru-memoizer instrumentation: restores the caller scope onto the memoized callback', async () => { + resetGlobals(); + const sink = transactionSink(); + init({ + dsn: 'https://username@domain/123', + tracesSampleRate: 1, + beforeSendTransaction: sink.beforeSendTransaction, + }); + + const channel = tracingChannel('orchestrion:lru-memoizer:load'); + const ctx = { arguments: [] }; + + let parentSpan: Span | undefined; + // `startSpanManual` leaves the span open after the callback but deactivates it, + // so the `asyncStart` below runs with no active span — a genuine detached context. + startSpanManual({ name: 'parent', op: 'test', forceTransaction: true }, span => { + parentSpan = span; + channel.start.runStores(ctx, () => undefined); + }); + + // Detached: no active span here. + assertEquals(getActiveSpan(), undefined); + + let restoredActive: Span | undefined; + channel.asyncStart.runStores(ctx, () => { + restoredActive = getActiveSpan(); + startSpan({ name: 'memoized-work', op: 'test' }, () => undefined); + }); + channel.asyncEnd.publish(ctx); + parentSpan!.end(); + + // The callback saw the caller's span restored. + assertEquals(restoredActive, parentSpan); + + const parent = await withTimeout( + sink.waitFor(t => t.transaction === 'parent'), + 5000, + "'parent' transaction", + ); + + // The span created in the restored callback nested under the caller, not a new trace. + const child = parent.spans?.find(s => s.description === 'memoized-work'); + assertExists( + child, + `expected memoized-work nested under parent, got: ${parent.spans?.map(s => s.description).join(', ')}`, + ); +}); diff --git a/packages/deno/src/index.ts b/packages/deno/src/index.ts index 95310d319a1e..404bdbabb833 100644 --- a/packages/deno/src/index.ts +++ b/packages/deno/src/index.ts @@ -121,6 +121,7 @@ export { genericPoolChannelIntegration, knexChannelIntegration, koaChannelIntegration, + lruMemoizerChannelIntegration, mongodbChannelIntegration, mongooseChannelIntegration, mysqlChannelIntegration, diff --git a/packages/deno/src/sdk.ts b/packages/deno/src/sdk.ts index 5c0c237207f1..78c85bd29a2c 100644 --- a/packages/deno/src/sdk.ts +++ b/packages/deno/src/sdk.ts @@ -15,6 +15,7 @@ import { amqplibChannelIntegration, genericPoolChannelIntegration, koaChannelIntegration, + lruMemoizerChannelIntegration, mongodbChannelIntegration, mongooseChannelIntegration, mysqlChannelIntegration, @@ -78,6 +79,7 @@ export function getDefaultIntegrations(_options: Options): Integration[] { amqplibChannelIntegration(), genericPoolChannelIntegration(), koaChannelIntegration(), + lruMemoizerChannelIntegration(), mongodbChannelIntegration(), mongooseChannelIntegration(), mysqlChannelIntegration(), diff --git a/packages/deno/test/__snapshots__/mod.test.ts.snap b/packages/deno/test/__snapshots__/mod.test.ts.snap index 2c8a22a7782d..a0aa2ff47068 100644 --- a/packages/deno/test/__snapshots__/mod.test.ts.snap +++ b/packages/deno/test/__snapshots__/mod.test.ts.snap @@ -118,6 +118,7 @@ snapshot[`captureException 1`] = ` "Amqplib", "GenericPool", "Koa", + "LruMemoizer", "Mongo", "Mongoose", "Mysql", @@ -203,6 +204,7 @@ snapshot[`captureMessage 1`] = ` "Amqplib", "GenericPool", "Koa", + "LruMemoizer", "Mongo", "Mongoose", "Mysql", @@ -295,6 +297,7 @@ snapshot[`captureMessage twice 1`] = ` "Amqplib", "GenericPool", "Koa", + "LruMemoizer", "Mongo", "Mongoose", "Mysql", @@ -394,6 +397,7 @@ snapshot[`captureMessage twice 2`] = ` "Amqplib", "GenericPool", "Koa", + "LruMemoizer", "Mongo", "Mongoose", "Mysql",