@exodus/error-tracking 2.2.0 → 3.0.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@2.2.0...@exodus/error-tracking@3.0.0) (2025-07-01)
+
+### ⚠ BREAKING CHANGES
+
+- merge errorTracking.track/trackRemote, enable/disable remote tracking based on config (#13038)
+
+### Features
+
+- feat!: merge errorTracking.track/trackRemote, enable/disable remote tracking based on config (#13038)
+
 ## [2.2.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@2.1.0...@exodus/error-tracking@2.2.0) (2025-06-23)
 
 ### Features

package/api/index.d.ts

@@ -11,16 +11,6 @@ export interface ErrorTrackingApi {
    * ```
    */
   track(params: { error: Error; namespace: string; context?: any }): Promise<void>
-  /**
-   * Track an error remotely using sentry if available
-   * @example
-   * ```typescript
-   * exodus.errors.trackRemote({
-   *   error: 'Encountered an issue when computing total balances',
-   * })
-   * ```
-   */
-  trackRemote(params: { error: string }): Promise<void>
 }
 
 declare const errorTrackingApiDefinition: {

package/api/index.js

@@ -1,33 +1,10 @@
-const createTrackRemote = ({ remoteErrorTracking, logger }) => {
-  if (!remoteErrorTracking) {
-    return async ({ error }) => {
-      logger.debug('remote error tracking is disabled', error)
-    }
-  }
-
-  return async ({ error }) => {
-    try {
-      await remoteErrorTracking.captureError({
-        error,
-      })
-    } catch (err) {
-      logger.error('failed to remote track error', err)
-    }
-  }
-}
-
 export const errorTrackingApiDefinition = {
   id: 'errorTrackingApi',
   type: 'api',
-  factory: ({ errorTracking, logger, remoteErrorTracking }) => {
-    const trackRemote = createTrackRemote({ remoteErrorTracking, logger })
-
-    return {
-      errors: {
-        track: errorTracking.track,
-        trackRemote,
-      },
-    }
-  },
-  dependencies: ['logger', 'remoteErrorTracking?', 'errorTracking'],
+  factory: ({ errorTracking }) => ({
+    errors: {
+      track: errorTracking.track,
+    },
+  }),
+  dependencies: ['errorTracking'],
 }

package/atoms/index.js

@@ -5,11 +5,16 @@ import { createInMemoryAtom } from '@exodus/atoms'
     errors: [{ `namespace`, `error`, `context`, `time` }, ...]
   }
 */
-const errorsAtomDefinition = {
+export const errorsAtomDefinition = {
   id: 'errorsAtom',
   type: 'atom',
   factory: () => createInMemoryAtom({ defaultValue: { errors: [] } }),
   dependencies: [],
 }
 
-export default errorsAtomDefinition
+export const remoteErrorTrackingEnabledAtomDefinition = {
+  id: 'remoteErrorTrackingEnabledAtom',
+  type: 'atom',
+  // eslint-disable-next-line @exodus/hydra/in-memory-atom-default-value
+  factory: () => createInMemoryAtom(),
+}

package/index.js

@@ -1,28 +1,47 @@
 import typeforce from '@exodus/typeforce'
 
-import { isEmpty } from './is-empty.js'
 import { errorTrackingApiDefinition } from './api/index.js'
-import errorTrackingAtomDefinition from './atoms/index.js'
+import { errorsAtomDefinition, remoteErrorTrackingEnabledAtomDefinition } from './atoms/index.js'
 import errorTrackingReportDefinition from './report/index.js'
 import { errorTrackingDefinition, remoteErrorTrackingDefinition } from './module/index.js'
+import errorTrackingPluginDefinition from './plugin/index.js'
 
-const defaultConfig = { maxErrorsCount: 100 }
+const defaultConfig = {
+  maxErrorsCount: 100,
+  sentryConfig: undefined,
+  remoteErrorTrackingABExperimentId: 'sentry',
+  trackWalletsCreatedAfter: new Date('2025-07-21'),
+  trackFundedWallets: false,
+}
 
 const configSchema = {
   maxErrorsCount: (value) => typeof value === 'number' && value > 0 && value <= 9999,
   sentryConfig: '?Object',
+  remoteErrorTrackingABExperimentId: '?String',
+  trackWalletsCreatedAfter: '?Date',
+  trackFundedWallets: '?Boolean',
 }
 
 const errorTracking = (config = Object.create(null)) => {
   config = { ...defaultConfig, ...config }
 
-  const { maxErrorsCount, sentryConfig } = typeforce.parse(configSchema, config)
+  const {
+    maxErrorsCount,
+    sentryConfig,
+    remoteErrorTrackingABExperimentId,
+    trackWalletsCreatedAfter,
+    trackFundedWallets,
+  } = typeforce.parse(configSchema, config, true)
 
+  const remoteErrorTrackingAvailable = !!sentryConfig && !!remoteErrorTrackingABExperimentId
   return {
     id: 'errorTracking',
     definitions: [
       {
-        definition: errorTrackingAtomDefinition,
+        definition: errorsAtomDefinition,
+      },
+      {
+        definition: remoteErrorTrackingEnabledAtomDefinition,
       },
       {
         definition: errorTrackingApiDefinition,
@@ -32,13 +51,22 @@ const errorTracking = (config = Object.create(null)) => {
         config: { maxErrorsCount },
       },
       {
-        if: sentryConfig !== undefined && sentryConfig !== null && !isEmpty(sentryConfig),
+        if: remoteErrorTrackingAvailable,
         definition: remoteErrorTrackingDefinition,
         config: sentryConfig,
       },
+      // deprecated, errors will go to sentry
       {
         definition: errorTrackingReportDefinition,
       },
+      {
+        definition: errorTrackingPluginDefinition,
+        config: {
+          remoteErrorTrackingABExperimentId,
+          trackWalletsCreatedAfter,
+          trackFundedWallets,
+        },
+      },
     ],
   }
 }

package/module/error-tracking.js

@@ -1,16 +1,25 @@
 const MODULE_ID = 'errorTracking'
 
-const createErrorTracking = ({ errorsAtom, config }) => {
+const createErrorTracking = ({
+  errorsAtom,
+  remoteErrorTrackingEnabledAtom,
+  remoteErrorTracking,
+  config,
+  logger,
+}) => {
   const track = async ({ error, context, namespace }) => {
-    if (!namespace) {
-      throw new Error('no namespace provided')
+    if (namespace !== undefined && typeof namespace !== 'string') {
+      throw new Error('namespace must be a string')
     }
 
     if (!(error instanceof Error)) {
       throw new TypeError('error must be an instance of Error')
     }
 
-    return errorsAtom.set(({ errors }) => {
+    // TODO: figure out what to do with `context`
+
+    // eventually kill this and only track remote
+    await errorsAtom.set(({ errors }) => {
       return {
         // this array can be big. not sure about prefering spread operator here
         // concat function seems like a better option
@@ -20,6 +29,15 @@ const createErrorTracking = ({ errorsAtom, config }) => {
           .slice(0, config.maxErrorsCount),
       }
     })
+
+    if (remoteErrorTracking) {
+      remoteErrorTrackingEnabledAtom
+        .get()
+        .then((enabled) => enabled && remoteErrorTracking.track({ error }))
+        .catch((err) => {
+          logger.error('failed to upload error', error, err)
+        })
+    }
   }
 
   return { track }
@@ -29,6 +47,12 @@ export const errorTrackingDefinition = {
   id: MODULE_ID,
   type: 'module',
   factory: createErrorTracking,
-  dependencies: ['config', 'errorsAtom'],
+  dependencies: [
+    'config',
+    'errorsAtom',
+    'remoteErrorTrackingEnabledAtom',
+    'remoteErrorTracking?',
+    'logger',
+  ],
   public: true,
 }

package/module/remote-error-tracking.js

@@ -6,10 +6,14 @@ export const remoteErrorTrackingDefinition = {
   type: 'module',
   factory: ({ config, fetch }) => {
     const fetchival = createFetchival({ fetch })
-    return createSentryClient({
+    const client = createSentryClient({
       config,
       fetchival,
     })
+
+    return {
+      track: ({ error }) => client.captureError({ error }),
+    }
   },
   dependencies: ['config', 'fetch'],
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/error-tracking",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "type": "module",
   "description": "A simple error tracking package to let any feature collect errors and create the report",
   "author": "Exodus Movement, Inc.",
@@ -16,14 +16,14 @@
   "main": "index.js",
   "exports": "./index.js",
   "files": [
-    "index.d.ts",
-    "is-empty.js",
     "api",
     "atoms",
     "module",
+    "plugin",
     "report",
     "CHANGELOG.md",
     "README.md",
+    "index.d.ts",
     "!**/__tests__/**"
   ],
   "scripts": {
@@ -43,5 +43,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "529b727a65d95366a9b7dd08b2e7acb6411b0de2"
+  "gitHead": "7425cf446dbe32c407ac46bd1c0463787cf8deb6"
 }

package/plugin/index.js

@@ -0,0 +1,82 @@
+import { combine, compute } from '@exodus/atoms'
+
+import whyIsRemoteTrackingDisabled from './why-is-remote-tracking-disabled.js'
+
+function errorTrackingPlugin({
+  abTestingAtom,
+  earliestTxDateAtom,
+  walletCreatedAtAtom,
+  getBuildMetadata,
+  remoteErrorTrackingEnabledAtom,
+  config: { remoteErrorTrackingABExperimentId, trackWalletsCreatedAfter, trackFundedWallets },
+  logger,
+}) {
+  const subscriptions = []
+
+  const onAssetsSynced = async () => {
+    if (!abTestingAtom) {
+      logger.debug('remote error tracking is disabled, ab-testing feature not found')
+      return
+    }
+
+    // defined locally instead of in /atoms to avoid circular dependency
+    // literally everything depends on error-tracking, so error-tracking atoms can't depend on other features
+    const internalRemoteErrorTrackingEnabledAtom = compute({
+      atom: combine({
+        abTesting: abTestingAtom,
+        earliestTxDate: earliestTxDateAtom,
+        walletCreatedAt: walletCreatedAtAtom,
+      }),
+      selector: async ({ abTesting, earliestTxDate, walletCreatedAt }) => {
+        const reasonDisabled = whyIsRemoteTrackingDisabled({
+          remoteErrorTrackingABExperimentId,
+          abTesting,
+          trackWalletsCreatedAfter,
+          walletCreatedAt,
+          trackFundedWallets,
+          earliestTxDate,
+          buildMetadata: await getBuildMetadata(),
+        })
+
+        if (reasonDisabled) {
+          logger.debug(`remote error tracking is disabled: ${reasonDisabled}`)
+          return false
+        }
+
+        logger.debug('remote error tracking is enabled')
+        return true
+      },
+    })
+
+    subscriptions.push(
+      internalRemoteErrorTrackingEnabledAtom.observe(remoteErrorTrackingEnabledAtom.set)
+    )
+  }
+
+  const onStop = () => {
+    subscriptions.forEach((unsubscribe) => unsubscribe())
+    subscriptions.length = 0
+  }
+
+  return {
+    onAssetsSynced,
+    onStop,
+  }
+}
+
+const errorTrackingPluginDefinition = {
+  id: 'errorTrackingPlugin',
+  type: 'plugin',
+  factory: errorTrackingPlugin,
+  dependencies: [
+    'abTestingAtom?',
+    'earliestTxDateAtom',
+    'walletCreatedAtAtom',
+    'remoteErrorTrackingEnabledAtom',
+    'getBuildMetadata',
+    'config',
+    'logger',
+  ],
+}
+
+export default errorTrackingPluginDefinition

package/plugin/why-is-remote-tracking-disabled.js

@@ -0,0 +1,23 @@
+export default function whyIsRemoteTrackingDisabled({
+  remoteErrorTrackingABExperimentId,
+  abTesting,
+  trackWalletsCreatedAfter,
+  walletCreatedAt,
+  trackFundedWallets,
+  earliestTxDate,
+  buildMetadata,
+}) {
+  if (!remoteErrorTrackingABExperimentId) return 'missing-ab-experiment-id'
+  if (!abTesting.experiments?.[remoteErrorTrackingABExperimentId]?.enabled)
+    return 'ab-experiment-disabled'
+  if (
+    trackWalletsCreatedAfter &&
+    // the negation's a bit harder to read but is a safer check
+    !(new Date(walletCreatedAt) > trackWalletsCreatedAfter)
+  ) {
+    return 'wallet-too-old'
+  }
+
+  if (!trackFundedWallets && earliestTxDate) return 'not-tracking-funded-wallets'
+  if (buildMetadata.dev) return 'dev-mode'
+}

package/is-empty.js

@@ -1,9 +0,0 @@
-export const isEmpty = (obj) => {
-  for (const prop in obj) {
-    if (Object.hasOwn(obj, prop)) {
-      return false
-    }
-  }
-
-  return true
-}