fixup! fixup! feat(deno)!: rename orchestrion integrations to match other SDKs

Adding a regression test to prove the bugbot finding.

Author: isaacs

dev-packages/deno-integration-tests/suites/direct-client-acs/scenario.mjs

@@ -0,0 +1,52 @@
+// Spawned by test.ts via `deno run`, in a fresh process so nothing else has
+// installed the AsyncLocalStorage context strategy.
+//
+// This builds a `DenoClient` DIRECTLY — `new DenoClient(...)` + `client.init()`
+// instead of calling `Sentry.init()`, then drives the mysql orchestrion channel
+// The mysql subscriber only binds once the ALS context strategy is installed
+// (it waits for the tracing-channel binding), so a nested db span here proves
+// `DenoClient.init()` installs that strategy on the direct-construction path.
+// Without it, the subscriber never binds and no span is produced.
+import { createStackParser, nodeStackLineParser } from '@sentry/core';
+import { DenoClient, getCurrentScope, getDefaultIntegrations, startSpan } from '@sentry/deno';
+import { tracingChannel } from 'node:diagnostics_channel';
+
+let nested = false;
+
+const client = new DenoClient({
+  dsn: 'https://username@domain/123',
+  tracesSampleRate: 1,
+  integrations: getDefaultIntegrations({}),
+  stackParser: createStackParser(nodeStackLineParser()),
+  beforeSendTransaction(event) {
+    const spans = event.spans ?? [];
+    if (spans.some(s => s.op === 'db' && s.data?.['sentry.origin'] === 'auto.db.orchestrion.mysql')) {
+      nested = true;
+    }
+    return null;
+  },
+  transport: () => ({ send: () => Promise.resolve({}), flush: () => Promise.resolve(true) }),
+});
+
+client.init();
+getCurrentScope().setClient(client);
+
+const channel = tracingChannel('orchestrion:mysql:query');
+const ctx = {
+  arguments: ['SELECT 1 AS solution'],
+  self: { config: { host: '127.0.0.1', port: 3306, database: 'mydb', user: 'root' } },
+};
+
+startSpan({ name: 'parent', op: 'test' }, () => {
+  channel.start.runStores(ctx, () => {
+    channel.end.publish(ctx);
+  });
+  channel.asyncStart.runStores(ctx, () => {
+    channel.asyncEnd.publish(ctx);
+  });
+});
+
+await client.flush(2000);
+
+// eslint-disable-next-line no-console
+console.log(`SCENARIO nested=${nested}`);

dev-packages/deno-integration-tests/suites/direct-client-acs/test.ts

@@ -0,0 +1,38 @@
+// <reference lib="deno.ns" />
+
+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';
+
+// A directly-constructed `DenoClient` (no `Sentry.init()`) is a supported path.
+// The SDK's own tests use it. It must still install the AsyncLocalStorage
+// context strategy, which the channel integrations depend on. We run it in a
+// fresh process so no prior `init()` has installed the strategy already, then
+// assert a nested mysql span appears (see scenario.mjs for why that proves the
+// strategy was installed by `client.init()`).
+Deno.test('DenoClient.init installs the AsyncLocalStorage strategy on the direct-construction path', async () => {
+  const scenario = new URL('./scenario.mjs', import.meta.url);
+
+  // The package root — where `node_modules` (and thus `@sentry/deno`) resolves
+  // for the spawned `deno run`.
+  const cwd = new URL('../../', import.meta.url);
+
+  const command = new Deno.Command('deno', {
+    args: ['run', '--allow-all', scenario.pathname],
+    cwd: cwd.pathname,
+    stdout: 'piped',
+    stderr: 'piped',
+  });
+
+  const { code, stdout, stderr } = await command.output();
+  const out = new TextDecoder().decode(stdout);
+  const err = new TextDecoder().decode(stderr);
+
+  assertEquals(code, 0, `scenario exited ${code}\nstdout:\n${out}\nstderr:\n${err}`);
+
+  const line = out.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+  assert(line, `no SCENARIO line in output:\n${out}\nstderr:\n${err}`);
+  assert(
+    line.includes('nested=true'),
+    `expected a nested mysql span via the direct client path (ACS must be installed by client.init), got: ${line}`,
+  );
+});