feat(deno): add langgraph integration

dev-packages/deno-integration-tests/src/index.ts

@@ -0,0 +1,59 @@
+import type { TransactionEvent } from '@sentry/core';
+import { getCurrentScope, getGlobalScope, getIsolationScope } from '@sentry/deno';
+
+/**
+ * Clear the current, isolation, and global scopes and detach the client so each
+ * test starts from a clean slate.
+ */
+export function resetGlobals(): void {
+  getCurrentScope().clear();
+  getCurrentScope().setClient(undefined);
+  getIsolationScope().clear();
+  getGlobalScope().clear();
+}
+
+export interface TransactionSink {
+  beforeSendTransaction: (event: TransactionEvent) => null;
+  waitFor: (predicate: (event: TransactionEvent) => boolean) => Promise<TransactionEvent>;
+}
+
+/**
+ * A `beforeSendTransaction` hook that records every transaction and lets a test
+ * `await` the first one matching a predicate. `waitFor` resolves immediately if
+ * a match already arrived, so there is no ordering race with the hook.
+ */
+export function transactionSink(): TransactionSink {
+  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<TransactionEvent>(resolve => {
+        waiters.push({ predicate, resolve });
+      });
+    },
+  };
+}
+
+/** Reject with a descriptive message if `p` does not settle within `ms`. */
+export function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<T>((_, 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);
+  });
+}

dev-packages/deno-integration-tests/suites/orchestrion-amqplib/test.ts

@@ -1,58 +1,12 @@
 // <reference lib="deno.ns" />
 
 import { tracingChannel } from 'node:diagnostics_channel';
-import type { TransactionEvent } from '@sentry/core';
 import type { DenoClient } from '@sentry/deno';
-import { getCurrentScope, getGlobalScope, getIsolationScope, init, startSpan } from '@sentry/deno';
+import { init, startSpan } from '@sentry/deno';
 import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts';
 import { assertExists } from 'https://deno.land/std@0.212.0/assert/assert_exists.ts';
 import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.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<TransactionEvent>;
-} {
-  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<TransactionEvent>(resolve => {
-        waiters.push({ predicate, resolve });
-      });
-    },
-  };
-}
-
-function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<T>((_, 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);
-  });
-}
+import { resetGlobals, transactionSink, withTimeout } from '../../src/index.ts';
 
 Deno.test('amqplib instrumentation: included in default integrations (Deno 2.8.0+)', () => {
   resetGlobals();

dev-packages/deno-integration-tests/suites/orchestrion-anthropic/test.ts

@@ -1,58 +1,12 @@
 // <reference lib="deno.ns" />
 
 import { tracingChannel } from 'node:diagnostics_channel';
-import type { TransactionEvent } from '@sentry/core';
 import type { DenoClient } from '@sentry/deno';
-import { getCurrentScope, getGlobalScope, getIsolationScope, init, startSpan } from '@sentry/deno';
+import { init, startSpan } from '@sentry/deno';
 import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts';
 import { assertExists } from 'https://deno.land/std@0.212.0/assert/assert_exists.ts';
 import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.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<TransactionEvent>;
-} {
-  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<TransactionEvent>(resolve => {
-        waiters.push({ predicate, resolve });
-      });
-    },
-  };
-}
-
-function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<T>((_, 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);
-  });
-}
+import { resetGlobals, transactionSink, withTimeout } from '../../src/index.ts';
 
 Deno.test('anthropic instrumentation: included in default integrations (Deno 2.8.0+)', () => {
   resetGlobals();

dev-packages/deno-integration-tests/suites/orchestrion-aws/test.ts

@@ -1,58 +1,13 @@
 // <reference lib="deno.ns" />
 
 import { tracingChannel } from 'node:diagnostics_channel';
-import type { Span, TransactionEvent } from '@sentry/core';
+import type { Span } from '@sentry/core';
 import type { DenoClient } from '@sentry/deno';
-import { getCurrentScope, getGlobalScope, getIsolationScope, init, spanToJSON, startSpan } from '@sentry/deno';
+import { init, spanToJSON, startSpan } from '@sentry/deno';
 import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts';
 import { assertExists } from 'https://deno.land/std@0.212.0/assert/assert_exists.ts';
 import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.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<TransactionEvent>;
-} {
-  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<TransactionEvent>(resolve => {
-        waiters.push({ predicate, resolve });
-      });
-    },
-  };
-}
-
-function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<T>((_, 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);
-  });
-}
+import { resetGlobals, transactionSink, withTimeout } from '../../src/index.ts';
 
 Deno.test('aws-sdk instrumentation: included in default integrations (Deno 2.8.0+)', () => {
   resetGlobals();

dev-packages/deno-integration-tests/suites/orchestrion-express/test.ts

@@ -2,58 +2,12 @@
 
 import { EventEmitter } from 'node:events';
 import { tracingChannel } from 'node:diagnostics_channel';
-import type { TransactionEvent } from '@sentry/core';
 import type { DenoClient } from '@sentry/deno';
-import { getCurrentScope, getGlobalScope, getIsolationScope, init, startSpan } from '@sentry/deno';
+import { init, startSpan } 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<TransactionEvent>;
-} {
-  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<TransactionEvent>(resolve => {
-        waiters.push({ predicate, resolve });
-      });
-    },
-  };
-}
-
-function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<T>((_, 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);
-  });
-}
+import { resetGlobals, transactionSink, withTimeout } from '../../src/index.ts';
 
 Deno.test('express instrumentation: included in default integrations (Deno 2.8.0+)', () => {
   resetGlobals();

dev-packages/deno-integration-tests/suites/orchestrion-firebase/test.ts

@@ -1,58 +1,12 @@
 // <reference lib="deno.ns" />
 
 import { tracingChannel } from 'node:diagnostics_channel';
-import type { TransactionEvent } from '@sentry/core';
 import type { DenoClient } from '@sentry/deno';
-import { getCurrentScope, getGlobalScope, getIsolationScope, init, startSpan } from '@sentry/deno';
+import { init, startSpan } from '@sentry/deno';
 import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts';
 import { assertExists } from 'https://deno.land/std@0.212.0/assert/assert_exists.ts';
 import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.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<TransactionEvent>;
-} {
-  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<TransactionEvent>(resolve => {
-        waiters.push({ predicate, resolve });
-      });
-    },
-  };
-}
-
-function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<T>((_, 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);
-  });
-}
+import { resetGlobals, transactionSink, withTimeout } from '../../src/index.ts';
 
 Deno.test('firebase instrumentation: included in default integrations (Deno 2.8.0+)', () => {
   resetGlobals();