@exodus/error-tracking 3.1.2 → 3.3.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.3.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@3.2.0...@exodus/error-tracking@3.3.0) (2025-11-20)
+
+### Features
+
+- feat: allow exporting `traceId` in errors context (#14099)
+
+## [3.2.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@3.1.2...@exodus/error-tracking@3.2.0) (2025-10-14)
+
+### Features
+
+- feat: support capturing error context (#13933)
+
 ## [3.1.2](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@3.1.1...@exodus/error-tracking@3.1.2) (2025-09-09)
 
 ### Bug Fixes

package/README.md

@@ -16,15 +16,46 @@ This feature is designed to be used together with `@exodus/headless`. See [using
 
 1. Open the playground https://exodus-hydra.pages.dev/features/errors
 2. Try out the some methods via the UI. These corresponds 1:1 with the `exodus.errors` API.
-3. Run `await exodus.errors.track({ namespace: 'balances', error: 'Encountered an issue when computing total balances', context: {} })` in the Dev Tools Console.
+3. Run in the Dev Tools Console:
+
+```ts
+await exodus.errors.track({
+  namespace: safeString`balances`,
+  error: new Error('Encountered an issue when computing total balances'),
+  context: {},
+})
+```
 
 ### API Side
 
 See [using the sdk](../../docs/development/using-the-sdk.md#setup-the-api-side) for more details on how features plug into the SDK and the API interface in the [type declaration](./api/index.d.ts).
 
 ```ts
-await exodus.errors.track({ namespace, error, context: {} })
-await exodus.errors.trackRemote({ error })
+import { safeString } from '@exodus/safe-string'
+import type { SafeContextType } from '@exodus/errors'
+
+// Track error with optional context (see SafeContextType for available properties).
+const context: SafeContextType = {
+  /* ... */
+}
+await exodus.errors.track({ namespace: safeString`wallet`, error, context })
+```
+
+**Important:** The `namespace` parameter must be a SafeString to prevent dynamic values from being used. Use the `safeString` template tag from `@exodus/safe-string`:
+
+```ts
+// ✅ Correct - safe string namespace
+await exodus.errors.track({
+  namespace: safeString`balances`,
+  error: new Error('Failed to compute balances'),
+})
+
+// ❌ Incorrect - plain strings not allowed
+const NAMESPACE = 'my-namespace'
+await exodus.errors.track({
+  namespace: NAMESPACE,
+  error: new Error('Some error'),
+})
 ```
 
 If you're building a feature and like to use error tracking inside that feature, you can depend on `errorTracking` and will receive the module with a track method that is auto-namespaced to your feature id.

package/api/index.d.ts

@@ -1,16 +1,20 @@
+import type { SafeString } from '@exodus/safe-string'
+
 export interface ErrorTrackingApi {
   /**
    * Track an error
    * @example
    * ```typescript
+   * import { safeString } from '@exodus/safe-string'
+   *
    * exodus.errors.track({
-   *   namespace: 'balances',
+   *   namespace: safeString`balances`,
    *   error: new Error('Encountered an issue when computing total balances'),
    *   context: {},
    * })
    * ```
    */
-  track(params: { error: Error; namespace: string; context?: any }): Promise<void>
+  track(params: { error: Error; namespace: SafeString; context?: any }): Promise<void>
 }
 
 declare const errorTrackingApiDefinition: {

package/module/error-tracking.js

@@ -1,3 +1,5 @@
+import { isSafe } from '@exodus/safe-string'
+
 const MODULE_ID = 'errorTracking'
 
 const createErrorTracking = ({
@@ -16,14 +18,21 @@ const createErrorTracking = ({
     logger.error(error)
 
     if (namespace !== undefined && typeof namespace !== 'string') {
-      return onError(new Error('namespace must be a string'))
+      return onError(new TypeError('namespace must be a string'))
+    }
+
+    if (namespace !== undefined && !isSafe(namespace)) {
+      return onError(
+        new TypeError(
+          'namespace must be a safe string. Use safeString`your-namespace` from @exodus/safe-string'
+        )
+      )
     }
 
     if (!(error instanceof Error)) {
       return onError(new TypeError('error must be an instance of Error'))
     }
 
-    // TODO: figure out what to do with `context`
     // TODO: eventually kill this and only track remote
     const localPromise = errorsAtom.set(({ errors }) => {
       return {
@@ -39,7 +48,7 @@ const createErrorTracking = ({
     const remotePromise = remoteErrorTracking
       ? remoteErrorTrackingEnabledAtom
           .get()
-          .then((enabled) => enabled && remoteErrorTracking.track({ error }))
+          .then((enabled) => enabled && remoteErrorTracking.track({ error, context }))
       : Promise.resolve()
 
     let timeoutId

package/module/index.d.ts

@@ -1,18 +1,22 @@
 import type { ErrorsAtom } from '../atoms/index.js'
+import type { SafeContextType } from '@exodus/errors'
+import type { SafeString } from '@exodus/safe-string'
 
 export interface ErrorTrackingModule {
   /**
    * Track an error
    * @example
    * ```typescript
+   * import { safeString } from '@exodus/safe-string'
+   *
    * errorTracking.track({
-   *   namespace: 'balances',
+   *   namespace: safeString`balances`,
    *   error: new Error('Encountered an issue when computing total balances'),
    *   context: {},
    * })
    * ```
    */
-  track(params: { error: Error; namespace: string; context?: any }): Promise<void>
+  track(params: { error: Error; namespace: SafeString; context?: SafeContextType }): Promise<void>
 }
 
 declare const errorTrackingModuleDefinition: {

package/module/remote-error-tracking.js

@@ -1,19 +1,16 @@
 import createSentryClient from '@exodus/sentry-client'
-import createFetchival from '@exodus/fetch/create-fetchival'
 
 export const remoteErrorTrackingDefinition = {
   id: 'remoteErrorTracking',
   type: 'module',
-  factory: ({ config, fetch }) => {
-    const fetchival = createFetchival({ fetch })
+  factory: ({ config }) => {
     const client = createSentryClient({
       config,
-      fetchival,
     })
 
     return {
-      track: ({ error }) => client.captureError({ error }),
+      track: ({ error, context }) => client.captureError({ error, context }),
     }
   },
-  dependencies: ['config', 'fetch'],
+  dependencies: ['config'],
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/error-tracking",
-  "version": "3.1.2",
+  "version": "3.3.0",
   "type": "module",
   "description": "A simple error tracking package to let any feature collect errors and create the report",
   "author": "Exodus Movement, Inc.",
@@ -34,14 +34,15 @@
   "dependencies": {
     "@exodus/atoms": "^9.0.0",
     "@exodus/basic-utils": "^3.0.1",
-    "@exodus/errors": "^3.0.0",
-    "@exodus/fetch": "^1.3.1",
-    "@exodus/sentry-client": "^6.0.0",
+    "@exodus/errors": "^3.4.0",
+    "@exodus/safe-string": "^1.2.1",
+    "@exodus/sentry-client": "^6.2.0",
     "@exodus/typeforce": "^1.19.0",
     "@exodus/zod": "^3.24.2"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": false
   },
-  "gitHead": "e9f71532ea6dbf4d7c9c6b40a755f221a5fd1de2"
+  "gitHead": "9ed826a1dfe2f679a84361594d376a58e4b51cb3"
 }

package/report/index.js

@@ -1,4 +1,4 @@
-import { SafeError } from '@exodus/errors'
+import { SafeError, SafeContext } from '@exodus/errors'
 import { memoize } from '@exodus/basic-utils'
 import { z } from '@exodus/zod'
 
@@ -14,6 +14,7 @@ const errorTrackingReportDefinition = {
           namespace,
           error: SafeError.from(error),
           time,
+          context,
         })),
       }
     },
@@ -26,6 +27,7 @@ const errorTrackingReportDefinition = {
                 namespace: z.string(),
                 error: z.instanceof(SafeError),
                 time: z.number(),
+                context: SafeContext.getSchema(),
               })
               .strict()
           ),