@logtape/sentry 2.2.0-dev.619 → 2.2.0-dev.620

package/README.md

@@ -47,6 +47,19 @@ deno add npm:@sentry/deno npm:@sentry/core
 bun add @sentry/bun
 ~~~~
 
+If your application initializes Sentry through a framework SDK such as
+`@sentry/nextjs` or `@sentry/react-native`, pass the same namespace object to
+the sink:
+
+~~~~ typescript
+import * as Sentry from "@sentry/nextjs";
+import { getSentrySink } from "@logtape/sentry";
+
+Sentry.init({ dsn: process.env.SENTRY_DSN });
+
+getSentrySink({ sentry: Sentry });
+~~~~
+
 
 Docs
 ----

package/dist/mod.cjs

@@ -59,13 +59,15 @@ function mapLevelForLogs(level) {
 /**
 * Gets a LogTape sink that sends logs to Sentry.
 *
-* This sink uses Sentry's global capture functions from `@sentry/core`,
-* following Sentry v8+ best practices. Simply call `Sentry.init()` before
-* creating the sink, and it will automatically use your initialized client.
+* This sink uses Sentry's global capture functions from `@sentry/core` by
+* default, following Sentry v8+ best practices. Simply call `Sentry.init()`
+* before creating the sink, and it will automatically use your initialized
+* client when both packages resolve the same Sentry module instance.
 *
 * @param optionsOrClient Optional configuration. Can be:
 *   - Omitted: Uses global Sentry functions (recommended)
 *   - Object with options: Configure sink behavior
+*   - Object with `sentry`: Use an application-provided Sentry SDK namespace
 *   - Sentry client instance: Backward compatibility (deprecated)
 * @returns A LogTape sink that sends logs to Sentry.
 *
@@ -87,6 +89,24 @@ function mapLevelForLogs(level) {
 * });
 * ```
 *
+* @example With an application-provided Sentry namespace
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getSentrySink } from "@logtape/sentry";
+* import * as Sentry from "@sentry/nextjs";
+*
+* Sentry.init({ dsn: process.env.SENTRY_DSN });
+*
+* await configure({
+*   sinks: {
+*     sentry: getSentrySink({ sentry: Sentry }),
+*   },
+*   loggers: [
+*     { category: [], sinks: ["sentry"], lowestLevel: "error" },
+*   ],
+* });
+* ```
+*
 * @example With options
 * ```typescript
 * import * as Sentry from "@sentry/node";
@@ -126,23 +146,25 @@ function mapLevelForLogs(level) {
 * @since 1.0.0
 */
 function getSentrySink(optionsOrClient) {
-	let sentry;
+	let legacyClient;
 	let options = {};
 	if (optionsOrClient == null) {} else if (typeof optionsOrClient === "object" && "captureMessage" in optionsOrClient && typeof optionsOrClient.captureMessage === "function") {
 		(0, __logtape_logtape.getLogger)([
 			"logtape",
 			"meta",
 			"sentry"
-		]).warn("Passing a client directly is deprecated and will be removed in v2.0.0. Use getSentrySink() instead - simpler and recommended!");
-		sentry = optionsOrClient;
+		]).warn("Passing a client directly is deprecated. Use getSentrySink({ sentry: Sentry }) instead.");
+		legacyClient = optionsOrClient;
 	} else if (typeof optionsOrClient === "object") options = optionsOrClient;
 	else throw new Error(`[@logtape/sentry] Invalid parameter (type: ${typeof optionsOrClient}).\n\nExpected one of:
   getSentrySink()              // Recommended
   getSentrySink({ options })   // With options
+  getSentrySink({ sentry })    // With a Sentry SDK namespace
   getSentrySink(client)        // Deprecated (v1.1.x compat)
 `);
-	const captureMessage = sentry ? (msg, ctx) => sentry.captureMessage(String(msg), ctx) : __sentry_core.captureMessage;
-	const captureException = sentry ? (exception, hint) => sentry.captureException(exception, hint) : __sentry_core.captureException;
+	const sentry = options.sentry ?? __sentry_core;
+	const captureMessage = legacyClient ? (msg, ctx) => legacyClient.captureMessage(String(msg), ctx) : sentry.captureMessage;
+	const captureException = legacyClient ? (exception, hint) => legacyClient.captureException(exception, hint) : sentry.captureException;
 	return (record) => {
 		try {
 			const { category } = record;
@@ -158,21 +180,21 @@ function getSentrySink(optionsOrClient) {
 				category: transformed.category.join("."),
 				timestamp: transformed.timestamp
 			};
-			const activeSpan = (0, __sentry_core.getActiveSpan)();
+			const activeSpan = sentry.getActiveSpan();
 			if (activeSpan) {
 				const spanCtx = activeSpan.spanContext();
 				attributes.trace_id = spanCtx.traceId;
 				attributes.span_id = spanCtx.spanId;
 				if ("parentSpanId" in spanCtx) attributes.parent_span_id = spanCtx.parentSpanId;
 			}
-			const client = (0, __sentry_core.getClient)();
+			const client = sentry.getClient();
 			if (client) {
 				const { enableLogs, _experiments } = client.getOptions();
 				const loggingEnabled = enableLogs ?? _experiments?.enableLogs;
-				if (loggingEnabled && "logger" in __sentry_core) {
+				const sentryLogger = sentry.logger;
+				if (loggingEnabled && sentryLogger != null) {
 					const logLevel = mapLevelForLogs(transformed.level);
-					const sentryLogger = __sentry_core.logger;
-					const logFn = sentryLogger?.[logLevel];
+					const logFn = sentryLogger[logLevel];
 					if (typeof logFn === "function") logFn(paramMessage, attributes);
 				}
 			}
@@ -191,7 +213,7 @@ function getSentrySink(optionsOrClient) {
 				extra: attributes
 			});
 			else if (options.enableBreadcrumbs) {
-				const isolationScope = (0, __sentry_core.getIsolationScope)();
+				const isolationScope = sentry.getIsolationScope();
 				isolationScope?.addBreadcrumb({
 					category: transformed.category.join("."),
 					level: eventLevel,

package/dist/mod.d.cts

@@ -1,5 +1,5 @@
 import { LogRecord, Sink } from "@logtape/logtape";
-import { SeverityLevel } from "@sentry/core";
+import { LogSeverityLevel, ParameterizedString, SeverityLevel } from "@sentry/core";
 
 //#region src/mod.d.ts
 
@@ -20,11 +20,86 @@ interface SentryInstance {
   captureMessage: (message: string, captureContext?: SeverityLevel | unknown) => string;
   captureException: (exception: unknown, hint?: unknown) => string;
 }
+/**
+ * A Sentry SDK namespace object.
+ *
+ * Pass the namespace imported by your application when *@logtape/sentry* should
+ * use the same Sentry module instance that initialized your app, for example
+ * `import * as Sentry from "@sentry/node"`.
+ *
+ * @since 2.2.0
+ */
+interface SentryNamespace {
+  /**
+   * Captures a message event and sends it to Sentry.
+   */
+  captureMessage(message: ParameterizedString, captureContext?: SeverityLevel | unknown): string;
+  /**
+   * Captures an exception event and sends it to Sentry.
+   */
+  captureException(exception: unknown, hint?: unknown): string;
+  /**
+   * Gets the currently active span, if any.
+   */
+  getActiveSpan(): {
+    spanContext: () => {
+      traceId: string;
+      spanId: string;
+      parentSpanId?: string;
+    };
+  } | undefined;
+  /**
+   * Gets the currently active Sentry client, if any.
+   */
+  getClient(): {
+    getOptions: () => {
+      enableLogs?: boolean;
+      _experiments?: {
+        enableLogs?: boolean;
+      };
+    };
+  } | undefined;
+  /**
+   * Gets the current isolation scope.
+   */
+  getIsolationScope(): {
+    addBreadcrumb: (breadcrumb: {
+      category: string;
+      level: SeverityLevel;
+      message: string;
+      timestamp: number;
+      data: Record<string, unknown>;
+    }) => void;
+  } | undefined;
+  /**
+   * Sentry's structured logging API, available in Sentry SDK 9.41.0+.
+   */
+  logger?: Partial<Record<LogSeverityLevel, (message: ParameterizedString, attributes: Record<string, unknown>) => void>>;
+}
 /**
  * Options for configuring the Sentry sink.
  * @since 1.3.0
  */
 interface SentrySinkOptions {
+  /**
+   * Sentry SDK namespace to use for capture, scope, span, and structured log
+   * APIs.
+   *
+   * This is useful when your application initializes Sentry through a framework
+   * SDK such as `@sentry/nextjs` or `@sentry/react-native`, and
+   * *@logtape/sentry* resolves a different `@sentry/core` module instance.
+   *
+   * @example
+   * ```typescript
+   * import * as Sentry from "@sentry/node";
+   *
+   * getSentrySink({ sentry: Sentry });
+   * ```
+   *
+   * @default `@sentry/core`
+   * @since 2.2.0
+   */
+  sentry?: SentryNamespace;
   /**
    * Enable automatic breadcrumb creation for log events.
    *
@@ -47,13 +122,15 @@ interface SentrySinkOptions {
 /**
  * Gets a LogTape sink that sends logs to Sentry.
  *
- * This sink uses Sentry's global capture functions from `@sentry/core`,
- * following Sentry v8+ best practices. Simply call `Sentry.init()` before
- * creating the sink, and it will automatically use your initialized client.
+ * This sink uses Sentry's global capture functions from `@sentry/core` by
+ * default, following Sentry v8+ best practices. Simply call `Sentry.init()`
+ * before creating the sink, and it will automatically use your initialized
+ * client when both packages resolve the same Sentry module instance.
  *
  * @param optionsOrClient Optional configuration. Can be:
  *   - Omitted: Uses global Sentry functions (recommended)
  *   - Object with options: Configure sink behavior
+ *   - Object with `sentry`: Use an application-provided Sentry SDK namespace
  *   - Sentry client instance: Backward compatibility (deprecated)
  * @returns A LogTape sink that sends logs to Sentry.
  *
@@ -75,6 +152,24 @@ interface SentrySinkOptions {
  * });
  * ```
  *
+ * @example With an application-provided Sentry namespace
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getSentrySink } from "@logtape/sentry";
+ * import * as Sentry from "@sentry/nextjs";
+ *
+ * Sentry.init({ dsn: process.env.SENTRY_DSN });
+ *
+ * await configure({
+ *   sinks: {
+ *     sentry: getSentrySink({ sentry: Sentry }),
+ *   },
+ *   loggers: [
+ *     { category: [], sinks: ["sentry"], lowestLevel: "error" },
+ *   ],
+ * });
+ * ```
+ *
  * @example With options
  * ```typescript
  * import * as Sentry from "@sentry/node";
@@ -116,5 +211,5 @@ interface SentrySinkOptions {
 declare function getSentrySink(optionsOrClient?: SentrySinkOptions | SentryInstance): Sink;
 //# sourceMappingURL=mod.d.ts.map
 //#endregion
-export { SentryInstance, SentrySinkOptions, getSentrySink };
+export { SentryInstance, SentryNamespace, SentrySinkOptions, getSentrySink };
 //# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmHA;AAYA;;;;AAmB+C;AAwE/C;;;;;AAEO,UAzGU,cAAA,CAyGV;qDAtGc;;;;;;;UASJ,iBAAA;;;;;;;;;;;;;;;;;;wBAmBO,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwEtB,aAAA,mBACI,oBAAoB,iBACrC"}
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4GA;AAiBA;;;;;;;;;;AA2DW,UA5EM,cAAA,CA4EN;EAAO,cAAA,EAAA,CAAA,OAAA,EAAA,MAAA,EAAA,cAAA,CAAA,EAzEG,aAyEH,GAAA,OAAA,EAAA,GAAA,MAAA;EAeD,gBAAA,EAAA,CAAA,SAAiB,EAAA,OAAA,EAAA,IAAA,CAAA,EAAA,OAAA,EAAA,GAAA,MAAA;;;;;AAuCa;AA4F/C;;;;;AAEO,UA/MU,eAAA,CA+MV;;;;0BA1MM,sCACQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA0CN;;;YAGD;;;;;;WAQH,QACP,OACE,4BAEW,iCACG;;;;;;UAUH,iBAAA;;;;;;;;;;;;;;;;;;;WAmBN;;;;;;;;;;;;;;;;;;wBAoBa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4FtB,aAAA,mBACI,oBAAoB,iBACrC"}

package/dist/mod.d.ts

@@ -1,5 +1,5 @@
 import { LogRecord, Sink } from "@logtape/logtape";
-import { SeverityLevel } from "@sentry/core";
+import { LogSeverityLevel, ParameterizedString, SeverityLevel } from "@sentry/core";
 
 //#region src/mod.d.ts
 
@@ -20,11 +20,86 @@ interface SentryInstance {
   captureMessage: (message: string, captureContext?: SeverityLevel | unknown) => string;
   captureException: (exception: unknown, hint?: unknown) => string;
 }
+/**
+ * A Sentry SDK namespace object.
+ *
+ * Pass the namespace imported by your application when *@logtape/sentry* should
+ * use the same Sentry module instance that initialized your app, for example
+ * `import * as Sentry from "@sentry/node"`.
+ *
+ * @since 2.2.0
+ */
+interface SentryNamespace {
+  /**
+   * Captures a message event and sends it to Sentry.
+   */
+  captureMessage(message: ParameterizedString, captureContext?: SeverityLevel | unknown): string;
+  /**
+   * Captures an exception event and sends it to Sentry.
+   */
+  captureException(exception: unknown, hint?: unknown): string;
+  /**
+   * Gets the currently active span, if any.
+   */
+  getActiveSpan(): {
+    spanContext: () => {
+      traceId: string;
+      spanId: string;
+      parentSpanId?: string;
+    };
+  } | undefined;
+  /**
+   * Gets the currently active Sentry client, if any.
+   */
+  getClient(): {
+    getOptions: () => {
+      enableLogs?: boolean;
+      _experiments?: {
+        enableLogs?: boolean;
+      };
+    };
+  } | undefined;
+  /**
+   * Gets the current isolation scope.
+   */
+  getIsolationScope(): {
+    addBreadcrumb: (breadcrumb: {
+      category: string;
+      level: SeverityLevel;
+      message: string;
+      timestamp: number;
+      data: Record<string, unknown>;
+    }) => void;
+  } | undefined;
+  /**
+   * Sentry's structured logging API, available in Sentry SDK 9.41.0+.
+   */
+  logger?: Partial<Record<LogSeverityLevel, (message: ParameterizedString, attributes: Record<string, unknown>) => void>>;
+}
 /**
  * Options for configuring the Sentry sink.
  * @since 1.3.0
  */
 interface SentrySinkOptions {
+  /**
+   * Sentry SDK namespace to use for capture, scope, span, and structured log
+   * APIs.
+   *
+   * This is useful when your application initializes Sentry through a framework
+   * SDK such as `@sentry/nextjs` or `@sentry/react-native`, and
+   * *@logtape/sentry* resolves a different `@sentry/core` module instance.
+   *
+   * @example
+   * ```typescript
+   * import * as Sentry from "@sentry/node";
+   *
+   * getSentrySink({ sentry: Sentry });
+   * ```
+   *
+   * @default `@sentry/core`
+   * @since 2.2.0
+   */
+  sentry?: SentryNamespace;
   /**
    * Enable automatic breadcrumb creation for log events.
    *
@@ -47,13 +122,15 @@ interface SentrySinkOptions {
 /**
  * Gets a LogTape sink that sends logs to Sentry.
  *
- * This sink uses Sentry's global capture functions from `@sentry/core`,
- * following Sentry v8+ best practices. Simply call `Sentry.init()` before
- * creating the sink, and it will automatically use your initialized client.
+ * This sink uses Sentry's global capture functions from `@sentry/core` by
+ * default, following Sentry v8+ best practices. Simply call `Sentry.init()`
+ * before creating the sink, and it will automatically use your initialized
+ * client when both packages resolve the same Sentry module instance.
  *
  * @param optionsOrClient Optional configuration. Can be:
  *   - Omitted: Uses global Sentry functions (recommended)
  *   - Object with options: Configure sink behavior
+ *   - Object with `sentry`: Use an application-provided Sentry SDK namespace
  *   - Sentry client instance: Backward compatibility (deprecated)
  * @returns A LogTape sink that sends logs to Sentry.
  *
@@ -75,6 +152,24 @@ interface SentrySinkOptions {
  * });
  * ```
  *
+ * @example With an application-provided Sentry namespace
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getSentrySink } from "@logtape/sentry";
+ * import * as Sentry from "@sentry/nextjs";
+ *
+ * Sentry.init({ dsn: process.env.SENTRY_DSN });
+ *
+ * await configure({
+ *   sinks: {
+ *     sentry: getSentrySink({ sentry: Sentry }),
+ *   },
+ *   loggers: [
+ *     { category: [], sinks: ["sentry"], lowestLevel: "error" },
+ *   ],
+ * });
+ * ```
+ *
  * @example With options
  * ```typescript
  * import * as Sentry from "@sentry/node";
@@ -116,5 +211,5 @@ interface SentrySinkOptions {
 declare function getSentrySink(optionsOrClient?: SentrySinkOptions | SentryInstance): Sink;
 //# sourceMappingURL=mod.d.ts.map
 //#endregion
-export { SentryInstance, SentrySinkOptions, getSentrySink };
+export { SentryInstance, SentryNamespace, SentrySinkOptions, getSentrySink };
 //# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmHA;AAYA;;;;AAmB+C;AAwE/C;;;;;AAEO,UAzGU,cAAA,CAyGV;qDAtGc;;;;;;;UASJ,iBAAA;;;;;;;;;;;;;;;;;;wBAmBO,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwEtB,aAAA,mBACI,oBAAoB,iBACrC"}
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4GA;AAiBA;;;;;;;;;;AA2DW,UA5EM,cAAA,CA4EN;EAAO,cAAA,EAAA,CAAA,OAAA,EAAA,MAAA,EAAA,cAAA,CAAA,EAzEG,aAyEH,GAAA,OAAA,EAAA,GAAA,MAAA;EAeD,gBAAA,EAAA,CAAA,SAAiB,EAAA,OAAA,EAAA,IAAA,CAAA,EAAA,OAAA,EAAA,GAAA,MAAA;;;;;AAuCa;AA4F/C;;;;;AAEO,UA/MU,eAAA,CA+MV;;;;0BA1MM,sCACQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA0CN;;;YAGD;;;;;;WAQH,QACP,OACE,4BAEW,iCACG;;;;;;UAUH,iBAAA;;;;;;;;;;;;;;;;;;;WAmBN;;;;;;;;;;;;;;;;;;wBAoBa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4FtB,aAAA,mBACI,oBAAoB,iBACrC"}

package/dist/mod.js

@@ -1,6 +1,5 @@
 import { compareLogLevel, getLogger } from "@logtape/logtape";
 import * as SentryCore from "@sentry/core";
-import { captureException, captureMessage, getActiveSpan, getClient, getIsolationScope } from "@sentry/core";
 
 //#region src/mod.ts
 /**
@@ -59,13 +58,15 @@ function mapLevelForLogs(level) {
 /**
 * Gets a LogTape sink that sends logs to Sentry.
 *
-* This sink uses Sentry's global capture functions from `@sentry/core`,
-* following Sentry v8+ best practices. Simply call `Sentry.init()` before
-* creating the sink, and it will automatically use your initialized client.
+* This sink uses Sentry's global capture functions from `@sentry/core` by
+* default, following Sentry v8+ best practices. Simply call `Sentry.init()`
+* before creating the sink, and it will automatically use your initialized
+* client when both packages resolve the same Sentry module instance.
 *
 * @param optionsOrClient Optional configuration. Can be:
 *   - Omitted: Uses global Sentry functions (recommended)
 *   - Object with options: Configure sink behavior
+*   - Object with `sentry`: Use an application-provided Sentry SDK namespace
 *   - Sentry client instance: Backward compatibility (deprecated)
 * @returns A LogTape sink that sends logs to Sentry.
 *
@@ -87,6 +88,24 @@ function mapLevelForLogs(level) {
 * });
 * ```
 *
+* @example With an application-provided Sentry namespace
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getSentrySink } from "@logtape/sentry";
+* import * as Sentry from "@sentry/nextjs";
+*
+* Sentry.init({ dsn: process.env.SENTRY_DSN });
+*
+* await configure({
+*   sinks: {
+*     sentry: getSentrySink({ sentry: Sentry }),
+*   },
+*   loggers: [
+*     { category: [], sinks: ["sentry"], lowestLevel: "error" },
+*   ],
+* });
+* ```
+*
 * @example With options
 * ```typescript
 * import * as Sentry from "@sentry/node";
@@ -126,23 +145,25 @@ function mapLevelForLogs(level) {
 * @since 1.0.0
 */
 function getSentrySink(optionsOrClient) {
-	let sentry;
+	let legacyClient;
 	let options = {};
 	if (optionsOrClient == null) {} else if (typeof optionsOrClient === "object" && "captureMessage" in optionsOrClient && typeof optionsOrClient.captureMessage === "function") {
 		getLogger([
 			"logtape",
 			"meta",
 			"sentry"
-		]).warn("Passing a client directly is deprecated and will be removed in v2.0.0. Use getSentrySink() instead - simpler and recommended!");
-		sentry = optionsOrClient;
+		]).warn("Passing a client directly is deprecated. Use getSentrySink({ sentry: Sentry }) instead.");
+		legacyClient = optionsOrClient;
 	} else if (typeof optionsOrClient === "object") options = optionsOrClient;
 	else throw new Error(`[@logtape/sentry] Invalid parameter (type: ${typeof optionsOrClient}).\n\nExpected one of:
   getSentrySink()              // Recommended
   getSentrySink({ options })   // With options
+  getSentrySink({ sentry })    // With a Sentry SDK namespace
   getSentrySink(client)        // Deprecated (v1.1.x compat)
 `);
-	const captureMessage$1 = sentry ? (msg, ctx) => sentry.captureMessage(String(msg), ctx) : captureMessage;
-	const captureException$1 = sentry ? (exception, hint) => sentry.captureException(exception, hint) : captureException;
+	const sentry = options.sentry ?? SentryCore;
+	const captureMessage = legacyClient ? (msg, ctx) => legacyClient.captureMessage(String(msg), ctx) : sentry.captureMessage;
+	const captureException = legacyClient ? (exception, hint) => legacyClient.captureException(exception, hint) : sentry.captureException;
 	return (record) => {
 		try {
 			const { category } = record;
@@ -158,40 +179,40 @@ function getSentrySink(optionsOrClient) {
 				category: transformed.category.join("."),
 				timestamp: transformed.timestamp
 			};
-			const activeSpan = getActiveSpan();
+			const activeSpan = sentry.getActiveSpan();
 			if (activeSpan) {
 				const spanCtx = activeSpan.spanContext();
 				attributes.trace_id = spanCtx.traceId;
 				attributes.span_id = spanCtx.spanId;
 				if ("parentSpanId" in spanCtx) attributes.parent_span_id = spanCtx.parentSpanId;
 			}
-			const client = getClient();
+			const client = sentry.getClient();
 			if (client) {
 				const { enableLogs, _experiments } = client.getOptions();
 				const loggingEnabled = enableLogs ?? _experiments?.enableLogs;
-				if (loggingEnabled && "logger" in SentryCore) {
+				const sentryLogger = sentry.logger;
+				if (loggingEnabled && sentryLogger != null) {
 					const logLevel = mapLevelForLogs(transformed.level);
-					const sentryLogger = SentryCore.logger;
-					const logFn = sentryLogger?.[logLevel];
+					const logFn = sentryLogger[logLevel];
 					if (typeof logFn === "function") logFn(paramMessage, attributes);
 				}
 			}
 			const isErrorLevel = compareLogLevel(transformed.level, "error") >= 0;
 			if (isErrorLevel && transformed.properties.error instanceof Error) {
 				const { error,...rest } = attributes;
-				captureException$1(error, {
+				captureException(error, {
 					level: eventLevel,
 					extra: {
 						message,
 						...rest
 					}
 				});
-			} else if (isErrorLevel) captureMessage$1(paramMessage, {
+			} else if (isErrorLevel) captureMessage(paramMessage, {
 				level: eventLevel,
 				extra: attributes
 			});
 			else if (options.enableBreadcrumbs) {
-				const isolationScope = getIsolationScope();
+				const isolationScope = sentry.getIsolationScope();
 				isolationScope?.addBreadcrumb({
 					category: transformed.category.join("."),
 					level: eventLevel,

package/dist/mod.js.map

@@ -1 +1 @@
-{"version":3,"file":"mod.js","names":["record: LogRecord","tplValues: string[]","inspect: (value: unknown) => string","level: LogLevel","optionsOrClient?: SentrySinkOptions | SentryInstance","sentry: SentryInstance | undefined","options: SentrySinkOptions","captureMessage","msg: ParameterizedString","ctx?: unknown","globalCaptureMessage","captureException","exception: unknown","hint?: unknown","globalCaptureException"],"sources":["../src/mod.ts"],"sourcesContent":["import {\n  compareLogLevel,\n  getLogger,\n  type LogLevel,\n  type LogRecord,\n  type Sink,\n} from \"@logtape/logtape\";\nimport type {\n  LogSeverityLevel,\n  ParameterizedString,\n  SeverityLevel,\n} from \"@sentry/core\";\n// Import namespace to safely check for public logger API (added in v9.41.0)\nimport * as SentryCore from \"@sentry/core\";\nimport {\n  captureException as globalCaptureException,\n  captureMessage as globalCaptureMessage,\n  getActiveSpan as globalGetActiveSpan,\n  getClient as globalGetClient,\n  getIsolationScope as globalGetIsolationScope,\n} from \"@sentry/core\";\n\n/**\n * Converts a LogTape {@link LogRecord} into a Sentry {@link ParameterizedString}.\n *\n * This preserves the template structure for better message grouping in Sentry,\n * allowing similar messages with different values to be grouped together.\n *\n * @param record The log record to convert.\n * @returns A parameterized string with template and values.\n */\nfunction getParameterizedString(record: LogRecord): ParameterizedString {\n  let result = \"\";\n  let tplString = \"\";\n  const tplValues: string[] = [];\n  for (let i = 0; i < record.message.length; i++) {\n    if (i % 2 === 0) {\n      result += record.message[i];\n      tplString += String(record.message[i]).replaceAll(\"%\", \"%%\");\n    } else {\n      const value = inspect(record.message[i]);\n      result += value;\n      tplString += `%s`;\n      tplValues.push(value);\n    }\n  }\n  const paramStr = new String(result) as ParameterizedString;\n  paramStr.__sentry_template_string__ = tplString;\n  paramStr.__sentry_template_values__ = tplValues;\n  return paramStr;\n}\n\n/**\n * A platform-specific inspect function. In Deno, this is {@link Deno.inspect},\n * and in Node.js/Bun it is {@link util.inspect}. If neither is available, it\n * falls back to {@link JSON.stringify}.\n *\n * @param value The value to inspect.\n * @returns The string representation of the value.\n */\nconst inspect: (value: unknown) => string =\n  // @ts-ignore: Deno global\n  \"Deno\" in globalThis && \"inspect\" in globalThis.Deno &&\n    // @ts-ignore: Deno global\n    typeof globalThis.Deno.inspect === \"function\"\n    // @ts-ignore: Deno global\n    ? globalThis.Deno.inspect\n    // @ts-ignore: Node.js global\n    : \"util\" in globalThis && \"inspect\" in globalThis.util &&\n        // @ts-ignore: Node.js global\n        typeof globalThis.util.inspect === \"function\"\n    // @ts-ignore: Node.js global\n    ? globalThis.util.inspect\n    : JSON.stringify;\n\n// Level normalization helpers\n\nfunction mapLevelForEvents(level: LogLevel): SeverityLevel {\n  switch (level) {\n    case \"trace\":\n      return \"debug\";\n    default:\n      return level as SeverityLevel; // debug | info | error | fatal\n  }\n}\n\nfunction mapLevelForLogs(level: LogLevel): LogSeverityLevel {\n  switch (level) {\n    case \"trace\":\n      return \"debug\";\n    case \"warning\":\n      return \"warn\";\n    case \"debug\":\n    case \"info\":\n    case \"error\":\n    case \"fatal\":\n      return level;\n    default:\n      return \"info\"; // fallback\n  }\n}\n\n/**\n * A Sentry client instance type (used for v1.1.x backward compatibility).\n *\n * Client instances only support `captureMessage` and `captureException`.\n * For scope operations (breadcrumbs, user context, traces), the sink always\n * uses global functions from `@sentry/core`.\n *\n * @deprecated This is only used for backward compatibility with v1.1.x.\n * New code should use `getSentrySink()` without parameters, which automatically\n * uses Sentry's global functions.\n *\n * @since 1.3.0\n */\nexport interface SentryInstance {\n  captureMessage: (\n    message: string,\n    captureContext?: SeverityLevel | unknown,\n  ) => string;\n  captureException: (exception: unknown, hint?: unknown) => string;\n}\n\n/**\n * Options for configuring the Sentry sink.\n * @since 1.3.0\n */\nexport interface SentrySinkOptions {\n  /**\n   * Enable automatic breadcrumb creation for log events.\n   *\n   * When enabled, all logs become breadcrumbs in Sentry's isolation scope,\n   * providing a complete context trail when errors occur. Breadcrumbs are\n   * lightweight and only appear in error reports for debugging.\n   *\n   * @default false\n   * @since 1.3.0\n   */\n  enableBreadcrumbs?: boolean;\n\n  /**\n   * Optional hook to transform or filter records before sending to Sentry.\n   * Return `null` to drop the record.\n   *\n   * @since 1.3.0\n   */\n  beforeSend?: (record: LogRecord) => LogRecord | null;\n}\n\n/**\n * Gets a LogTape sink that sends logs to Sentry.\n *\n * This sink uses Sentry's global capture functions from `@sentry/core`,\n * following Sentry v8+ best practices. Simply call `Sentry.init()` before\n * creating the sink, and it will automatically use your initialized client.\n *\n * @param optionsOrClient Optional configuration. Can be:\n *   - Omitted: Uses global Sentry functions (recommended)\n *   - Object with options: Configure sink behavior\n *   - Sentry client instance: Backward compatibility (deprecated)\n * @returns A LogTape sink that sends logs to Sentry.\n *\n * @example Recommended usage - no parameters\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getSentrySink } from \"@logtape/sentry\";\n * import * as Sentry from \"@sentry/node\";\n *\n * Sentry.init({ dsn: process.env.SENTRY_DSN });\n *\n * await configure({\n *   sinks: {\n *     sentry: getSentrySink(),  // That's it!\n *   },\n *   loggers: [\n *     { category: [], sinks: [\"sentry\"], lowestLevel: \"error\" },\n *   ],\n * });\n * ```\n *\n * @example With options\n * ```typescript\n * import * as Sentry from \"@sentry/node\";\n * Sentry.init({ dsn: process.env.SENTRY_DSN });\n *\n * await configure({\n *   sinks: {\n *     sentry: getSentrySink({\n *       enableBreadcrumbs: true,\n *     }),\n *   },\n *   loggers: [\n *     { category: [], sinks: [\"sentry\"], lowestLevel: \"info\" },\n *   ],\n * });\n * ```\n *\n * @example Edge functions - must flush before termination\n * ```typescript\n * // Cloudflare Workers\n * export default {\n *   async fetch(request, env, ctx) {\n *     logger.error(\"Something happened\");\n *     ctx.waitUntil(Sentry.flush(2000));  // Don't block response\n *     return new Response(\"OK\");\n *   }\n * };\n * ```\n *\n * @example Legacy usage (v1.1.x - deprecated)\n * ```typescript\n * import { getClient } from \"@sentry/node\";\n * const client = getClient();\n * getSentrySink(client);  // Still works but shows deprecation warning\n * ```\n *\n * @since 1.0.0\n */\nexport function getSentrySink(\n  optionsOrClient?: SentrySinkOptions | SentryInstance,\n): Sink {\n  let sentry: SentryInstance | undefined;\n  let options: SentrySinkOptions = {};\n\n  // Detect which API pattern is being used\n  if (optionsOrClient == null) {\n    // Pattern: getSentrySink() - no params (RECOMMENDED)\n    // Use global functions\n  } else if (\n    typeof optionsOrClient === \"object\" &&\n    \"captureMessage\" in optionsOrClient &&\n    typeof optionsOrClient.captureMessage === \"function\"\n  ) {\n    // Pattern: getSentrySink(client) - DEPRECATED (v1.1.x backward compatibility)\n    getLogger([\"logtape\", \"meta\", \"sentry\"]).warn(\n      \"Passing a client directly is deprecated and will be removed in v2.0.0. \" +\n        \"Use getSentrySink() instead - simpler and recommended!\",\n    );\n    sentry = optionsOrClient as SentryInstance;\n  } else if (typeof optionsOrClient === \"object\") {\n    // Pattern: getSentrySink({ options }) - options object\n    options = optionsOrClient as SentrySinkOptions;\n  } else {\n    throw new Error(\n      `[@logtape/sentry] Invalid parameter (type: ${typeof optionsOrClient}).\\n\\n` +\n        \"Expected one of:\\n\" +\n        \"  getSentrySink()              // Recommended\\n\" +\n        \"  getSentrySink({ options })   // With options\\n\" +\n        \"  getSentrySink(client)        // Deprecated (v1.1.x compat)\\n\",\n    );\n  }\n\n  // Choose which Sentry functions to use:\n  // - For capture functions: use client if provided (v1.1.x compat), otherwise globals\n  // - For scope operations: ALWAYS use globals (client doesn't have these methods)\n  const captureMessage = sentry\n    ? (msg: ParameterizedString, ctx?: unknown) =>\n      sentry.captureMessage(String(msg), ctx)\n    : globalCaptureMessage;\n  const captureException = sentry\n    ? (exception: unknown, hint?: unknown) =>\n      sentry.captureException(exception, hint)\n    : globalCaptureException;\n\n  return (record: LogRecord) => {\n    try {\n      // Skip meta logger records to prevent infinite recursion\n      const { category } = record;\n      if (\n        category[0] === \"logtape\" && category[1] === \"meta\" &&\n        category[2] === \"sentry\"\n      ) {\n        return;\n      }\n\n      // Optional transformation/filtering\n      const transformed = options.beforeSend\n        ? options.beforeSend(record)\n        : record;\n      if (transformed == null) return;\n\n      // Parameterized message for structured logging and events\n      const paramMessage = getParameterizedString(transformed);\n      const message = paramMessage.toString();\n\n      // Level mapping\n      const eventLevel = mapLevelForEvents(transformed.level);\n\n      // Enriched structured attributes\n      const attributes = {\n        ...transformed.properties,\n        \"sentry.origin\": \"auto.logging.logtape\",\n        category: transformed.category.join(\".\"),\n        timestamp: transformed.timestamp,\n      } as Record<string, unknown>;\n\n      // After enriched attributes\n      const activeSpan = globalGetActiveSpan();\n      if (activeSpan) {\n        const spanCtx = activeSpan.spanContext();\n        attributes.trace_id = spanCtx.traceId;\n        attributes.span_id = spanCtx.spanId;\n        if (\"parentSpanId\" in spanCtx) {\n          attributes.parent_span_id = spanCtx.parentSpanId; // Optional\n        }\n      }\n\n      // Send structured log if Sentry logging is enabled (v9.41.0+)\n      // Uses public logger API when available (SDK 9.41.0+)\n      const client = globalGetClient();\n      if (client) {\n        const { enableLogs, _experiments } = client.getOptions();\n        const loggingEnabled = enableLogs ?? _experiments?.enableLogs;\n\n        if (loggingEnabled && \"logger\" in SentryCore) {\n          const logLevel = mapLevelForLogs(transformed.level);\n          const sentryLogger = SentryCore.logger as unknown as\n            | Record<\n              string,\n              ((msg: ParameterizedString, attrs: unknown) => void)\n            >\n            | undefined;\n          const logFn = sentryLogger?.[logLevel];\n          if (typeof logFn === \"function\") {\n            logFn(paramMessage, attributes);\n          }\n        }\n      }\n\n      // Capture as Sentry event (Issue) based on level and error presence\n      // Use compareLogLevel() to handle future severity level additions\n      const isErrorLevel = compareLogLevel(transformed.level, \"error\") >= 0;\n\n      if (isErrorLevel && transformed.properties.error instanceof Error) {\n        // Error instance at error/fatal level -> captureException for stack trace\n        const { error, ...rest } = attributes;\n        captureException(error as Error, {\n          level: eventLevel,\n          extra: { message, ...rest },\n        });\n      } else if (isErrorLevel) {\n        // Error/fatal level without Error instance -> captureMessage as Issue\n        captureMessage(paramMessage, {\n          level: eventLevel,\n          extra: attributes,\n        });\n      } else if (options.enableBreadcrumbs) {\n        // Non-error levels -> breadcrumbs only (if enabled)\n        const isolationScope = globalGetIsolationScope();\n        isolationScope?.addBreadcrumb({\n          category: transformed.category.join(\".\"),\n          level: eventLevel,\n          message,\n          timestamp: transformed.timestamp / 1000,\n          data: attributes,\n        });\n      }\n    } catch (err) {\n      // Never throw from a sink; keep failures silent but visible in debug\n      try {\n        console.debug(\"[@logtape/sentry] sink error\", err);\n      } catch { /* ignore console errors */ }\n    }\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"mod.js","names":["record: LogRecord","tplValues: string[]","inspect: (value: unknown) => string","level: LogLevel","optionsOrClient?: SentrySinkOptions | SentryInstance","legacyClient: SentryInstance | undefined","options: SentrySinkOptions","msg: ParameterizedString","ctx?: unknown","exception: unknown","hint?: unknown"],"sources":["../src/mod.ts"],"sourcesContent":["import {\n  compareLogLevel,\n  getLogger,\n  type LogLevel,\n  type LogRecord,\n  type Sink,\n} from \"@logtape/logtape\";\nimport type {\n  LogSeverityLevel,\n  ParameterizedString,\n  SeverityLevel,\n} from \"@sentry/core\";\n// Import namespace to safely check for public logger API (added in v9.41.0)\nimport * as SentryCore from \"@sentry/core\";\n\n/**\n * Converts a LogTape {@link LogRecord} into a Sentry {@link ParameterizedString}.\n *\n * This preserves the template structure for better message grouping in Sentry,\n * allowing similar messages with different values to be grouped together.\n *\n * @param record The log record to convert.\n * @returns A parameterized string with template and values.\n */\nfunction getParameterizedString(record: LogRecord): ParameterizedString {\n  let result = \"\";\n  let tplString = \"\";\n  const tplValues: string[] = [];\n  for (let i = 0; i < record.message.length; i++) {\n    if (i % 2 === 0) {\n      result += record.message[i];\n      tplString += String(record.message[i]).replaceAll(\"%\", \"%%\");\n    } else {\n      const value = inspect(record.message[i]);\n      result += value;\n      tplString += `%s`;\n      tplValues.push(value);\n    }\n  }\n  const paramStr = new String(result) as ParameterizedString;\n  paramStr.__sentry_template_string__ = tplString;\n  paramStr.__sentry_template_values__ = tplValues;\n  return paramStr;\n}\n\n/**\n * A platform-specific inspect function. In Deno, this is {@link Deno.inspect},\n * and in Node.js/Bun it is {@link util.inspect}. If neither is available, it\n * falls back to {@link JSON.stringify}.\n *\n * @param value The value to inspect.\n * @returns The string representation of the value.\n */\nconst inspect: (value: unknown) => string =\n  // @ts-ignore: Deno global\n  \"Deno\" in globalThis && \"inspect\" in globalThis.Deno &&\n    // @ts-ignore: Deno global\n    typeof globalThis.Deno.inspect === \"function\"\n    // @ts-ignore: Deno global\n    ? globalThis.Deno.inspect\n    // @ts-ignore: Node.js global\n    : \"util\" in globalThis && \"inspect\" in globalThis.util &&\n        // @ts-ignore: Node.js global\n        typeof globalThis.util.inspect === \"function\"\n    // @ts-ignore: Node.js global\n    ? globalThis.util.inspect\n    : JSON.stringify;\n\n// Level normalization helpers\n\nfunction mapLevelForEvents(level: LogLevel): SeverityLevel {\n  switch (level) {\n    case \"trace\":\n      return \"debug\";\n    default:\n      return level as SeverityLevel; // debug | info | error | fatal\n  }\n}\n\nfunction mapLevelForLogs(level: LogLevel): LogSeverityLevel {\n  switch (level) {\n    case \"trace\":\n      return \"debug\";\n    case \"warning\":\n      return \"warn\";\n    case \"debug\":\n    case \"info\":\n    case \"error\":\n    case \"fatal\":\n      return level;\n    default:\n      return \"info\"; // fallback\n  }\n}\n\n/**\n * A Sentry client instance type (used for v1.1.x backward compatibility).\n *\n * Client instances only support `captureMessage` and `captureException`.\n * For scope operations (breadcrumbs, user context, traces), the sink always\n * uses global functions from `@sentry/core`.\n *\n * @deprecated This is only used for backward compatibility with v1.1.x.\n * New code should use `getSentrySink()` without parameters, which automatically\n * uses Sentry's global functions.\n *\n * @since 1.3.0\n */\nexport interface SentryInstance {\n  captureMessage: (\n    message: string,\n    captureContext?: SeverityLevel | unknown,\n  ) => string;\n  captureException: (exception: unknown, hint?: unknown) => string;\n}\n\n/**\n * A Sentry SDK namespace object.\n *\n * Pass the namespace imported by your application when *@logtape/sentry* should\n * use the same Sentry module instance that initialized your app, for example\n * `import * as Sentry from \"@sentry/node\"`.\n *\n * @since 2.2.0\n */\nexport interface SentryNamespace {\n  /**\n   * Captures a message event and sends it to Sentry.\n   */\n  captureMessage(\n    message: ParameterizedString,\n    captureContext?: SeverityLevel | unknown,\n  ): string;\n\n  /**\n   * Captures an exception event and sends it to Sentry.\n   */\n  captureException(exception: unknown, hint?: unknown): string;\n\n  /**\n   * Gets the currently active span, if any.\n   */\n  getActiveSpan():\n    | {\n      spanContext: () => {\n        traceId: string;\n        spanId: string;\n        parentSpanId?: string;\n      };\n    }\n    | undefined;\n\n  /**\n   * Gets the currently active Sentry client, if any.\n   */\n  getClient():\n    | {\n      getOptions: () => {\n        enableLogs?: boolean;\n        _experiments?: {\n          enableLogs?: boolean;\n        };\n      };\n    }\n    | undefined;\n\n  /**\n   * Gets the current isolation scope.\n   */\n  getIsolationScope():\n    | {\n      addBreadcrumb: (breadcrumb: {\n        category: string;\n        level: SeverityLevel;\n        message: string;\n        timestamp: number;\n        data: Record<string, unknown>;\n      }) => void;\n    }\n    | undefined;\n\n  /**\n   * Sentry's structured logging API, available in Sentry SDK 9.41.0+.\n   */\n  logger?: Partial<\n    Record<\n      LogSeverityLevel,\n      (\n        message: ParameterizedString,\n        attributes: Record<string, unknown>,\n      ) => void\n    >\n  >;\n}\n\n/**\n * Options for configuring the Sentry sink.\n * @since 1.3.0\n */\nexport interface SentrySinkOptions {\n  /**\n   * Sentry SDK namespace to use for capture, scope, span, and structured log\n   * APIs.\n   *\n   * This is useful when your application initializes Sentry through a framework\n   * SDK such as `@sentry/nextjs` or `@sentry/react-native`, and\n   * *@logtape/sentry* resolves a different `@sentry/core` module instance.\n   *\n   * @example\n   * ```typescript\n   * import * as Sentry from \"@sentry/node\";\n   *\n   * getSentrySink({ sentry: Sentry });\n   * ```\n   *\n   * @default `@sentry/core`\n   * @since 2.2.0\n   */\n  sentry?: SentryNamespace;\n\n  /**\n   * Enable automatic breadcrumb creation for log events.\n   *\n   * When enabled, all logs become breadcrumbs in Sentry's isolation scope,\n   * providing a complete context trail when errors occur. Breadcrumbs are\n   * lightweight and only appear in error reports for debugging.\n   *\n   * @default false\n   * @since 1.3.0\n   */\n  enableBreadcrumbs?: boolean;\n\n  /**\n   * Optional hook to transform or filter records before sending to Sentry.\n   * Return `null` to drop the record.\n   *\n   * @since 1.3.0\n   */\n  beforeSend?: (record: LogRecord) => LogRecord | null;\n}\n\n/**\n * Gets a LogTape sink that sends logs to Sentry.\n *\n * This sink uses Sentry's global capture functions from `@sentry/core` by\n * default, following Sentry v8+ best practices. Simply call `Sentry.init()`\n * before creating the sink, and it will automatically use your initialized\n * client when both packages resolve the same Sentry module instance.\n *\n * @param optionsOrClient Optional configuration. Can be:\n *   - Omitted: Uses global Sentry functions (recommended)\n *   - Object with options: Configure sink behavior\n *   - Object with `sentry`: Use an application-provided Sentry SDK namespace\n *   - Sentry client instance: Backward compatibility (deprecated)\n * @returns A LogTape sink that sends logs to Sentry.\n *\n * @example Recommended usage - no parameters\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getSentrySink } from \"@logtape/sentry\";\n * import * as Sentry from \"@sentry/node\";\n *\n * Sentry.init({ dsn: process.env.SENTRY_DSN });\n *\n * await configure({\n *   sinks: {\n *     sentry: getSentrySink(),  // That's it!\n *   },\n *   loggers: [\n *     { category: [], sinks: [\"sentry\"], lowestLevel: \"error\" },\n *   ],\n * });\n * ```\n *\n * @example With an application-provided Sentry namespace\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getSentrySink } from \"@logtape/sentry\";\n * import * as Sentry from \"@sentry/nextjs\";\n *\n * Sentry.init({ dsn: process.env.SENTRY_DSN });\n *\n * await configure({\n *   sinks: {\n *     sentry: getSentrySink({ sentry: Sentry }),\n *   },\n *   loggers: [\n *     { category: [], sinks: [\"sentry\"], lowestLevel: \"error\" },\n *   ],\n * });\n * ```\n *\n * @example With options\n * ```typescript\n * import * as Sentry from \"@sentry/node\";\n * Sentry.init({ dsn: process.env.SENTRY_DSN });\n *\n * await configure({\n *   sinks: {\n *     sentry: getSentrySink({\n *       enableBreadcrumbs: true,\n *     }),\n *   },\n *   loggers: [\n *     { category: [], sinks: [\"sentry\"], lowestLevel: \"info\" },\n *   ],\n * });\n * ```\n *\n * @example Edge functions - must flush before termination\n * ```typescript\n * // Cloudflare Workers\n * export default {\n *   async fetch(request, env, ctx) {\n *     logger.error(\"Something happened\");\n *     ctx.waitUntil(Sentry.flush(2000));  // Don't block response\n *     return new Response(\"OK\");\n *   }\n * };\n * ```\n *\n * @example Legacy usage (v1.1.x - deprecated)\n * ```typescript\n * import { getClient } from \"@sentry/node\";\n * const client = getClient();\n * getSentrySink(client);  // Still works but shows deprecation warning\n * ```\n *\n * @since 1.0.0\n */\nexport function getSentrySink(\n  optionsOrClient?: SentrySinkOptions | SentryInstance,\n): Sink {\n  let legacyClient: SentryInstance | undefined;\n  let options: SentrySinkOptions = {};\n\n  // Detect which API pattern is being used\n  if (optionsOrClient == null) {\n    // Pattern: getSentrySink() - no params (RECOMMENDED)\n    // Use global functions\n  } else if (\n    typeof optionsOrClient === \"object\" &&\n    \"captureMessage\" in optionsOrClient &&\n    typeof optionsOrClient.captureMessage === \"function\"\n  ) {\n    // Pattern: getSentrySink(client) - DEPRECATED (v1.1.x backward compatibility)\n    getLogger([\"logtape\", \"meta\", \"sentry\"]).warn(\n      \"Passing a client directly is deprecated. \" +\n        \"Use getSentrySink({ sentry: Sentry }) instead.\",\n    );\n    legacyClient = optionsOrClient as SentryInstance;\n  } else if (typeof optionsOrClient === \"object\") {\n    // Pattern: getSentrySink({ options }) - options object\n    options = optionsOrClient as SentrySinkOptions;\n  } else {\n    throw new Error(\n      `[@logtape/sentry] Invalid parameter (type: ${typeof optionsOrClient}).\\n\\n` +\n        \"Expected one of:\\n\" +\n        \"  getSentrySink()              // Recommended\\n\" +\n        \"  getSentrySink({ options })   // With options\\n\" +\n        \"  getSentrySink({ sentry })    // With a Sentry SDK namespace\\n\" +\n        \"  getSentrySink(client)        // Deprecated (v1.1.x compat)\\n\",\n    );\n  }\n\n  const sentry = options.sentry ?? SentryCore;\n\n  // Choose which Sentry functions to use:\n  // - For capture functions: use client if provided (v1.1.x compat),\n  //   otherwise the configured SDK namespace.\n  // - For scope operations: use the configured SDK namespace because clients\n  //   don't expose current scope/span APIs.\n  const captureMessage = legacyClient\n    ? (msg: ParameterizedString, ctx?: unknown) =>\n      legacyClient.captureMessage(String(msg), ctx)\n    : sentry.captureMessage;\n  const captureException = legacyClient\n    ? (exception: unknown, hint?: unknown) =>\n      legacyClient.captureException(exception, hint)\n    : sentry.captureException;\n\n  return (record: LogRecord) => {\n    try {\n      // Skip meta logger records to prevent infinite recursion\n      const { category } = record;\n      if (\n        category[0] === \"logtape\" && category[1] === \"meta\" &&\n        category[2] === \"sentry\"\n      ) {\n        return;\n      }\n\n      // Optional transformation/filtering\n      const transformed = options.beforeSend\n        ? options.beforeSend(record)\n        : record;\n      if (transformed == null) return;\n\n      // Parameterized message for structured logging and events\n      const paramMessage = getParameterizedString(transformed);\n      const message = paramMessage.toString();\n\n      // Level mapping\n      const eventLevel = mapLevelForEvents(transformed.level);\n\n      // Enriched structured attributes\n      const attributes = {\n        ...transformed.properties,\n        \"sentry.origin\": \"auto.logging.logtape\",\n        category: transformed.category.join(\".\"),\n        timestamp: transformed.timestamp,\n      } as Record<string, unknown>;\n\n      // After enriched attributes\n      const activeSpan = sentry.getActiveSpan();\n      if (activeSpan) {\n        const spanCtx = activeSpan.spanContext();\n        attributes.trace_id = spanCtx.traceId;\n        attributes.span_id = spanCtx.spanId;\n        if (\"parentSpanId\" in spanCtx) {\n          attributes.parent_span_id = spanCtx.parentSpanId; // Optional\n        }\n      }\n\n      // Send structured log if Sentry logging is enabled (v9.41.0+)\n      // Uses public logger API when available (SDK 9.41.0+)\n      const client = sentry.getClient();\n      if (client) {\n        const { enableLogs, _experiments } = client.getOptions();\n        const loggingEnabled = enableLogs ?? _experiments?.enableLogs;\n\n        const sentryLogger = sentry.logger as SentryNamespace[\"logger\"];\n        if (loggingEnabled && sentryLogger != null) {\n          const logLevel = mapLevelForLogs(transformed.level);\n          const logFn = sentryLogger[logLevel];\n          if (typeof logFn === \"function\") {\n            logFn(paramMessage, attributes);\n          }\n        }\n      }\n\n      // Capture as Sentry event (Issue) based on level and error presence\n      // Use compareLogLevel() to handle future severity level additions\n      const isErrorLevel = compareLogLevel(transformed.level, \"error\") >= 0;\n\n      if (isErrorLevel && transformed.properties.error instanceof Error) {\n        // Error instance at error/fatal level -> captureException for stack trace\n        const { error, ...rest } = attributes;\n        captureException(error as Error, {\n          level: eventLevel,\n          extra: { message, ...rest },\n        });\n      } else if (isErrorLevel) {\n        // Error/fatal level without Error instance -> captureMessage as Issue\n        captureMessage(paramMessage, {\n          level: eventLevel,\n          extra: attributes,\n        });\n      } else if (options.enableBreadcrumbs) {\n        // Non-error levels -> breadcrumbs only (if enabled)\n        const isolationScope = sentry.getIsolationScope();\n        isolationScope?.addBreadcrumb({\n          category: transformed.category.join(\".\"),\n          level: eventLevel,\n          message,\n          timestamp: transformed.timestamp / 1000,\n          data: attributes,\n        });\n      }\n    } catch (err) {\n      // Never throw from a sink; keep failures silent but visible in debug\n      try {\n        console.debug(\"[@logtape/sentry] sink error\", err);\n      } catch { /* ignore console errors */ }\n    }\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/sentry",
-  "version": "2.2.0-dev.619+83dde3d4",
+  "version": "2.2.0-dev.620+455a47e2",
   "description": "LogTape Sentry sink",
   "keywords": [
     "LogTape",
@@ -45,7 +45,7 @@
   ],
   "peerDependencies": {
     "@sentry/core": ">=8.0.0",
-    "@logtape/logtape": "^2.2.0-dev.619+83dde3d4"
+    "@logtape/logtape": "^2.2.0-dev.620+455a47e2"
   },
   "devDependencies": {
     "@sentry/core": "^9.41.0",