feat(deno): Export logs API from Deno SDK (#19313)

## Summary
- Re-export `logger` and `consoleLoggingIntegration` from `@sentry/core`
in the Deno SDK
- Add integration test verifying `logger.info()` produces a log envelope
item with correct `level` and `body`

## Test plan
- [x] `yarn build:dev:filter @sentry/deno` — builds successfully
- [x] `cd packages/deno && yarn test` — all 13 tests pass
- [x] `eslint packages/deno/src/index.ts` — no lint errors

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Closes #19314 (added automatically)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: sergical

packages/deno/src/client.ts

@@ -1,5 +1,5 @@
 import type { ServerRuntimeClientOptions } from '@sentry/core';
-import { SDK_VERSION, ServerRuntimeClient } from '@sentry/core';
+import { _INTERNAL_flushLogsBuffer, SDK_VERSION, ServerRuntimeClient } from '@sentry/core';
 import type { DenoClientOptions } from './types';
 
 function getHostName(): string | undefined {
@@ -19,6 +19,8 @@ function getHostName(): string | undefined {
  * @see SentryClient for usage documentation.
  */
 export class DenoClient extends ServerRuntimeClient<DenoClientOptions> {
+  private _logOnExitFlushListener: (() => void) | undefined;
+
   /**
    * Creates a new Deno SDK instance.
    * @param options Configuration options for this SDK.
@@ -36,13 +38,42 @@ export class DenoClient extends ServerRuntimeClient<DenoClientOptions> {
       version: SDK_VERSION,
     };
 
+    const serverName = options.serverName || getHostName();
+
     const clientOptions: ServerRuntimeClientOptions = {
       ...options,
       platform: 'javascript',
       runtime: { name: 'deno', version: Deno.version.deno },
-      serverName: options.serverName || getHostName(),
+      serverName,
     };
 
     super(clientOptions);
+
+    if (this.getOptions().enableLogs) {
+      this._logOnExitFlushListener = () => {
+        _INTERNAL_flushLogsBuffer(this);
+      };
+
+      if (serverName) {
+        this.on('beforeCaptureLog', log => {
+          log.attributes = {
+            ...log.attributes,
+            'server.address': serverName,
+          };
+        });
+      }
+
+      globalThis.addEventListener('unload', this._logOnExitFlushListener);
+    }
+  }
+
+  /** @inheritDoc */
+  // @ts-expect-error - PromiseLike is a subset of Promise
+  public async close(timeout?: number | undefined): PromiseLike<boolean> {
+    if (this._logOnExitFlushListener) {
+      globalThis.removeEventListener('unload', this._logOnExitFlushListener);
+    }
+
+    return super.close(timeout);
   }
 }

packages/deno/src/index.ts

@@ -1,6 +1,8 @@
 export type {
   Breadcrumb,
   BreadcrumbHint,
+  Log,
+  LogSeverityLevel,
   Metric,
   PolymorphicRequest,
   RequestEventData,
@@ -91,6 +93,8 @@ export {
   wrapMcpServerWithSentry,
   featureFlagsIntegration,
   metrics,
+  logger,
+  consoleLoggingIntegration,
 } from '@sentry/core';
 
 export { DenoClient } from './client';

packages/deno/test/mod.test.ts

@@ -1,8 +1,8 @@
-import type { Envelope, Event } from '@sentry/core';
+import type { Envelope, Event, Log } from '@sentry/core';
 import { createStackParser, forEachEnvelopeItem, nodeStackLineParser } from '@sentry/core';
 import { assertEquals } from 'https://deno.land/std@0.202.0/assert/assert_equals.ts';
 import { assertSnapshot } from 'https://deno.land/std@0.202.0/testing/snapshot.ts';
-import { DenoClient, getCurrentScope, getDefaultIntegrations, metrics, Scope } from '../build/esm/index.js';
+import { DenoClient, getCurrentScope, getDefaultIntegrations, logger, metrics, Scope } from '../build/esm/index.js';
 import { getNormalizedEvent } from './normalize.ts';
 import { makeTestTransport } from './transport.ts';
 
@@ -111,6 +111,102 @@ Deno.test('metrics.count captures a counter metric', async () => {
   assertEquals(metricItem.items[0].value, 5);
 });
 
+Deno.test('logger.info captures a log envelope item', async () => {
+  const envelopes: Array<Envelope> = [];
+  const client = new DenoClient({
+    dsn: 'https://233a45e5efe34c47a3536797ce15dafa@nothing.here/5650507',
+    enableLogs: true,
+    integrations: getDefaultIntegrations({}),
+    stackParser: createStackParser(nodeStackLineParser()),
+    transport: makeTestTransport(envelope => {
+      envelopes.push(envelope);
+    }),
+  });
+
+  client.init();
+  const scope = new Scope();
+  scope.setClient(client);
+
+  logger.info('test log message', { key: 'value' }, { scope });
+
+  await client.flush(2000);
+
+  // deno-lint-ignore no-explicit-any
+  let logItem: any = undefined;
+  for (const envelope of envelopes) {
+    forEachEnvelopeItem(envelope, item => {
+      const [headers, body] = item;
+      if (headers.type === 'log') {
+        logItem = body;
+      }
+    });
+  }
+
+  assertEquals(logItem !== undefined, true);
+  assertEquals(logItem.items.length, 1);
+  assertEquals(logItem.items[0].level, 'info');
+  assertEquals(logItem.items[0].body, 'test log message');
+});
+
+Deno.test('adds server.address to log attributes', () => {
+  const client = new DenoClient({
+    dsn: 'https://233a45e5efe34c47a3536797ce15dafa@nothing.here/5650507',
+    enableLogs: true,
+    serverName: 'test-server',
+    integrations: getDefaultIntegrations({}),
+    stackParser: createStackParser(nodeStackLineParser()),
+    transport: makeTestTransport(() => {}),
+  });
+
+  const log: Log = { level: 'info', message: 'test message', attributes: {} };
+  client.emit('beforeCaptureLog', log);
+
+  assertEquals(log.attributes?.['server.address'], 'test-server');
+});
+
+Deno.test('preserves existing log attributes when adding server.address', () => {
+  const client = new DenoClient({
+    dsn: 'https://233a45e5efe34c47a3536797ce15dafa@nothing.here/5650507',
+    enableLogs: true,
+    serverName: 'test-server',
+    integrations: getDefaultIntegrations({}),
+    stackParser: createStackParser(nodeStackLineParser()),
+    transport: makeTestTransport(() => {}),
+  });
+
+  const log: Log = { level: 'info', message: 'test message', attributes: { 'existing.attr': 'value' } };
+  client.emit('beforeCaptureLog', log);
+
+  assertEquals(log.attributes?.['existing.attr'], 'value');
+  assertEquals(log.attributes?.['server.address'], 'test-server');
+});
+
+Deno.test('close() removes unload listener when enableLogs is true', async () => {
+  const removeEventListenerCalls: Array<string> = [];
+  const originalRemoveEventListener = globalThis.removeEventListener;
+  globalThis.removeEventListener = ((event: string, ...args: unknown[]) => {
+    removeEventListenerCalls.push(event);
+    // deno-lint-ignore no-explicit-any
+    return originalRemoveEventListener.call(globalThis, event, ...(args as [any]));
+  }) as typeof globalThis.removeEventListener;
+
+  try {
+    const client = new DenoClient({
+      dsn: 'https://233a45e5efe34c47a3536797ce15dafa@nothing.here/5650507',
+      enableLogs: true,
+      integrations: getDefaultIntegrations({}),
+      stackParser: createStackParser(nodeStackLineParser()),
+      transport: makeTestTransport(() => {}),
+    });
+
+    await client.close();
+
+    assertEquals(removeEventListenerCalls.includes('unload'), true);
+  } finally {
+    globalThis.removeEventListener = originalRemoveEventListener;
+  }
+});
+
 Deno.test('App runs without errors', async _ => {
   const cmd = new Deno.Command('deno', {
     args: ['run', '--allow-net=some-domain.com', './test/example.ts'],