Add Sentry error property option

Add SentrySinkOptions.errorPropertyNames so applications can choose
which structured log properties are inspected for Error instances. The
sink still defaults to the existing error and err property order, while
custom lists replace that default and preserve their configured order.

Document the option and cover custom property names and precedence with
regression tests.

#189

Assisted-by: Codex:gpt-5.5

Author: dahlia

CHANGES.md

@@ -29,7 +29,7 @@ To be released.
     test callback and reporting them only when the callback fails by default.
     The reporter uses scoped configuration, preserves wrapped callback
     parameters, and supports `mode: "on-failure"`, `mode: "always"`, and
-    `mode: "never"`.  [[#186], [#189]]
+    `mode: "never"`.  [[#186], [#190]]
 
      -  Added `FailureLogReporter` interface with `wrap()` and `run()`
         methods.
@@ -41,7 +41,7 @@ To be released.
         `@logtape/testing` export for compatibility.
 
 [#186]: https://github.com/dahlia/logtape/issues/186
-[#189]: https://github.com/dahlia/logtape/pull/189
+[#190]: https://github.com/dahlia/logtape/pull/190
 
 ### @logtape/file
 
@@ -69,6 +69,15 @@ To be released.
 
 [#184]: https://github.com/dahlia/logtape/pull/184
 
+### @logtape/sentry
+
+ -  Added `SentrySinkOptions.errorPropertyNames` option to customize which
+    structured log properties are checked for `Error` instances before the
+    Sentry sink chooses `captureException()`.  The default remains
+    `["error", "err"]`.  [[#189]]
+
+[#189]: https://github.com/dahlia/logtape/issues/189
+
 
 Version 2.2.3
 -------------

docs/sinks/sentry.md

@@ -253,6 +253,30 @@ logger.error("User not found: {userId}", { userId: 123 });
 logger.info("Request received", { path: "/api/users" });
 ~~~~
 
+You can customize which property names are checked for an `Error` instance with
+the `errorPropertyNames` option. Names are checked in order, and the first
+matching `Error` is sent to `captureException`:
+
+~~~~ typescript twoslash
+// @noErrors: 2305 2307
+import * as Sentry from "@sentry/node";
+import { configure } from "@logtape/logtape";
+import { getSentrySink } from "@logtape/sentry";
+
+Sentry.init({ dsn: process.env.SENTRY_DSN });
+
+await configure({
+  sinks: {
+    sentry: getSentrySink({
+      errorPropertyNames: ["exception", "error", "err"],
+    }),
+  },
+  loggers: [
+    { category: [], sinks: ["sentry"], lowestLevel: "error" },
+  ],
+});
+~~~~
+
 All logs are sent to Sentry's structured logging (when `enableLogs: true`) and
 can become breadcrumbs (when `enableBreadcrumbs: true`), providing full context
 when errors occur.

packages/sentry/src/mod.test.ts

@@ -244,6 +244,61 @@ test("sink prefers error property over err property", () => {
   assert.strictEqual(extra.err, err);
 });
 
+test("sink uses configured error property names", () => {
+  let capturedException: unknown;
+  let capturedHint: unknown;
+  const error = new Error("Default");
+  const exception = new Error("Custom");
+  const sink = getSentrySink({
+    errorPropertyNames: ["exception"],
+    sentry: createMockSentryNamespace({
+      captureException: (capturedExceptionValue, hint) => {
+        capturedException = capturedExceptionValue;
+        capturedHint = hint;
+        return "exception-id";
+      },
+    }),
+  });
+
+  sink(createMockLogRecord({
+    level: "error",
+    properties: { error, exception, requestId: "request-1" },
+  }));
+
+  const extra = (capturedHint as { extra: Record<string, unknown> }).extra;
+  assert.strictEqual(capturedException, exception);
+  assert.strictEqual(extra.error, error);
+  assert.strictEqual("exception" in extra, false);
+  assert.strictEqual(extra.requestId, "request-1");
+});
+
+test("sink uses configured error property order", () => {
+  let capturedException: unknown;
+  let capturedHint: unknown;
+  const error = new Error("Default");
+  const exception = new Error("Custom");
+  const sink = getSentrySink({
+    errorPropertyNames: ["exception", "error"],
+    sentry: createMockSentryNamespace({
+      captureException: (capturedExceptionValue, hint) => {
+        capturedException = capturedExceptionValue;
+        capturedHint = hint;
+        return "exception-id";
+      },
+    }),
+  });
+
+  sink(createMockLogRecord({
+    level: "error",
+    properties: { error, exception },
+  }));
+
+  const extra = (capturedHint as { extra: Record<string, unknown> }).extra;
+  assert.strictEqual(capturedException, exception);
+  assert.strictEqual(extra.error, error);
+  assert.strictEqual("exception" in extra, false);
+});
+
 test("sink without Error at error level does not trigger exception path", () => {
   let sawError = false;
   const sink = getSentrySink({

packages/sentry/src/mod.ts

@@ -74,14 +74,16 @@ function mapLevelForLogs(level: LogLevel): LogSeverityLevel {
   }
 }
 
+const defaultErrorPropertyNames = ["error", "err"] as const;
+
 function getErrorProperty(
   properties: Readonly<Record<string, unknown>>,
-): readonly [property: "error" | "err", error: Error] | undefined {
-  if (properties.error instanceof Error) {
-    return ["error", properties.error];
-  }
-  if (properties.err instanceof Error) {
-    return ["err", properties.err];
+  propertyNames: readonly string[],
+): readonly [property: string, error: Error] | undefined {
+  for (const property of propertyNames) {
+    if (properties[property] instanceof Error) {
+      return [property, properties[property]];
+    }
   }
   return undefined;
 }
@@ -223,6 +225,19 @@ export interface SentrySinkOptions {
    */
   enableBreadcrumbs?: boolean;
 
+  /**
+   * Property names to inspect for an `Error` instance when deciding whether
+   * error-level records should be sent through Sentry's `captureException()`.
+   *
+   * Names are checked in order, and the first property containing an `Error`
+   * instance is used as the captured exception.  Set this to a custom list when
+   * your application or logger stores the primary exception under another name.
+   *
+   * @default `["error", "err"]`
+   * @since 2.3.0
+   */
+  errorPropertyNames?: readonly string[];
+
   /**
    * Optional hook to transform or filter records before sending to Sentry.
    * Return `null` to drop the record.
@@ -435,7 +450,10 @@ export function getSentrySink(
       // Capture as Sentry event (Issue) based on level and error presence
       // Use compareLogLevel() to handle future severity level additions
       const isErrorLevel = compareLogLevel(transformed.level, "error") >= 0;
-      const errorProperty = getErrorProperty(transformed.properties);
+      const errorProperty = getErrorProperty(
+        transformed.properties,
+        options.errorPropertyNames ?? defaultErrorPropertyNames,
+      );
 
       if (isErrorLevel && errorProperty != null) {
         // Error instance at error/fatal level -> captureException for stack trace