@exodus/error-tracking 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.3.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@1.2.1...@exodus/error-tracking@1.3.0) (2024-10-03)
+
+### Features
+
+- add error tracking API types ([#9579](https://github.com/ExodusMovement/exodus-hydra/issues/9579)) ([317e40b](https://github.com/ExodusMovement/exodus-hydra/commit/317e40bde1007f7d192379ab390e3aed0a6ebd1a))
+- use atoms v9 ([#9651](https://github.com/ExodusMovement/exodus-hydra/issues/9651)) ([524aa61](https://github.com/ExodusMovement/exodus-hydra/commit/524aa61f69c81e6ac00b2f94ea830688a105b3e4))
+
+## [1.2.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@1.2.0...@exodus/error-tracking@1.2.1) (2024-08-13)
+
+**Note:** Version bump only for package @exodus/error-tracking
+
 ## [1.2.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/error-tracking@1.1.3...@exodus/error-tracking@1.2.0) (2024-08-08)
 
 ### Features

package/README.md

@@ -8,23 +8,23 @@ A simple namespaces error tracking package to let any feature collect errors and
 yarn add @exodus/error-tracking
 ```
 
-## Methods
-
-`#errorTracking.track({ namespace: string, error: Error | string, context: Object })`
-
-Collects tracked error to the provided namespaced error list.
-
 ## Usage
 
-### With a dependency injection container
+This feature is designed to be used together with `@exodus/headless`. See [using the sdk](../../docs/docs-website/docs/development/using-the-sdk.md).
 
-```js
-import errorTracking from '@exodus/error-tracking'
+### Play with it
 
-const ioc = createIocContainer()
+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.
 
-const config = { maxErrorsCount: 20 }
-ioc.use(errorTracking(config))
+### API Side
 
-ioc.resolve()
+See [using the sdk](../../docs/docs-website/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 })
 ```
+
+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

@@ -0,0 +1,34 @@
+export interface ErrorTrackingApi {
+  /**
+   * Track an error
+   * @example
+   * ```typescript
+   * exodus.errors.track({
+   *   namespace: 'balances',
+   *   error: 'Encountered an issue when computing total balances',
+   *   context: {},
+   * })
+   * ```
+   */
+  track(params: { error: string | 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: {
+  id: 'errorTrackingApi'
+  type: 'api'
+  factory(): {
+    errors: ErrorTrackingApi
+  }
+}
+
+export default errorTrackingApiDefinition

package/api/index.js

@@ -1,38 +1,33 @@
-import { createErrorTracking } from '../module/create-error-tracking.js'
+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: ({ errorsAtom, config, logger, remoteErrorTracking }) => {
-    const { track } = createErrorTracking({ errorsAtom, config })
-
-    let trackRemote
-    if (remoteErrorTracking) {
-      trackRemote = async ({ error }) => {
-        try {
-          await remoteErrorTracking.captureError({
-            error,
-          })
-        } catch (err) {
-          logger.error('failed to remote track error', err)
-        }
-      }
-    } else {
-      trackRemote = async ({ error }) => {
-        logger.debug('remote error tracking is disabled', error)
-      }
-    }
+  factory: ({ errorTracking, logger, remoteErrorTracking }) => {
+    const trackRemote = createTrackRemote({ remoteErrorTracking, logger })
 
     return {
       errors: {
-        track,
+        track: errorTracking.track,
         trackRemote,
       },
     }
   },
-  dependencies: ['config', 'errorsAtom', 'logger', 'remoteErrorTracking?'],
+  dependencies: ['logger', 'remoteErrorTracking?', 'errorTracking'],
 }
-
-// Implementation Note: It would have made more sense to add the `errorTracking` module as a dependency instead of
-// just its factory function. However, the issue is that adding errorTracking as a dependency to this API node
-// will cause the error-tracking-preprocessor to change the track function definition, which is not what we require here.

package/index.d.ts

@@ -0,0 +1,8 @@
+import type errorTrackingApiDefinition from './api/index.js'
+
+declare const errorTracking: () => {
+  id: 'errorTracking'
+  definitions: [{ definition: typeof errorTrackingApiDefinition }]
+}
+
+export default errorTracking

package/index.js

@@ -1,34 +1,46 @@
-import { isEmpty } from './is-empty.js'
+import typeforce from '@exodus/typeforce'
 
+import { isEmpty } from './is-empty.js'
 import { errorTrackingApiDefinition } from './api/index.js'
-
 import errorTrackingAtomDefinition from './atoms/index.js'
 import errorTrackingReportDefinition from './report/index.js'
 import { errorTrackingDefinition, remoteErrorTrackingDefinition } from './module/index.js'
 
-const errorTracking = ({ maxErrorsCount = 100, sentryConfig } = Object.create(null)) => ({
-  id: 'errorTracking',
-  definitions: [
-    {
-      definition: errorTrackingAtomDefinition,
-    },
-    {
-      definition: errorTrackingApiDefinition,
-      config: { maxErrorsCount },
-    },
-    {
-      definition: errorTrackingDefinition,
-      config: { maxErrorsCount },
-    },
-    {
-      if: sentryConfig !== undefined && sentryConfig !== null && !isEmpty(sentryConfig),
-      definition: remoteErrorTrackingDefinition,
-      config: sentryConfig,
-    },
-    {
-      definition: errorTrackingReportDefinition,
-    },
-  ],
-})
+const defaultConfig = { maxErrorsCount: 100 }
+
+const configSchema = {
+  maxErrorsCount: (value) => typeof value === 'number' && value > 0 && value <= 9999,
+  sentryConfig: '?Object',
+}
+
+const errorTracking = (config = Object.create(null)) => {
+  config = { ...defaultConfig, ...config }
+
+  const { maxErrorsCount, sentryConfig } = typeforce.parse(configSchema, config)
+
+  return {
+    id: 'errorTracking',
+    definitions: [
+      {
+        definition: errorTrackingAtomDefinition,
+      },
+      {
+        definition: errorTrackingApiDefinition,
+      },
+      {
+        definition: errorTrackingDefinition,
+        config: { maxErrorsCount },
+      },
+      {
+        if: sentryConfig !== undefined && sentryConfig !== null && !isEmpty(sentryConfig),
+        definition: remoteErrorTrackingDefinition,
+        config: sentryConfig,
+      },
+      {
+        definition: errorTrackingReportDefinition,
+      },
+    ],
+  }
+}
 
 export default errorTracking

package/module/error-tracking.js

@@ -1,7 +1,26 @@
-import { createErrorTracking } from './create-error-tracking.js'
-
 const MODULE_ID = 'errorTracking'
 
+const createErrorTracking = ({ errorsAtom, config }) => {
+  const track = async ({ error, context, namespace }) => {
+    if (!namespace) {
+      throw new Error('no namespace provided')
+    }
+
+    return errorsAtom.set(({ errors }) => {
+      return {
+        // this array can be big. not sure about prefering spread operator here
+        // concat function seems like a better option
+        errors: [{ namespace, error, context, time: Date.now() }]
+          // eslint-disable-next-line unicorn/prefer-spread
+          .concat(errors)
+          .slice(0, config.maxErrorsCount),
+      }
+    })
+  }
+
+  return { track }
+}
+
 export const errorTrackingDefinition = {
   id: MODULE_ID,
   type: 'module',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/error-tracking",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "A simple error tracking package to let any feature collect errors and create the report",
   "author": "Exodus Movement, Inc.",
@@ -16,7 +16,7 @@
   "main": "index.js",
   "exports": "./index.js",
   "files": [
-    ".",
+    "index.d.ts",
     "is-empty.js",
     "api",
     "atoms",
@@ -28,15 +28,15 @@
   ],
   "scripts": {
     "test": "run -T jest",
-    "lint": "run -T eslint . --ignore-path ../../.gitignore",
+    "lint": "run -T eslint -c ../../eslint.config.mjs",
     "lint:fix": "yarn lint --fix"
   },
   "dependencies": {
-    "@exodus/atoms": "^8.0.0",
+    "@exodus/atoms": "^9.0.0",
     "@exodus/basic-utils": "^3.0.1",
     "@exodus/fetch": "^1.3.1",
     "@exodus/sentry-client": "^3.2.0",
     "@exodus/typeforce": "^1.19.0"
   },
-  "gitHead": "795fabca74101cee3be6c9a0581b327e9cc3293f"
+  "gitHead": "6172788cc9a82ac74c1228d228e5743b894eb245"
 }

package/module/create-error-tracking.js

@@ -1,30 +0,0 @@
-import typeforce from '@exodus/typeforce'
-
-export const createErrorTracking = ({ errorsAtom, config }) => {
-  const { maxErrorsCount } = typeforce.parse(
-    {
-      maxErrorsCount: (value) => typeof value === 'number' && value > 0 && value <= 9999,
-    },
-    config
-  )
-
-  const track = async ({ error, context, namespace }) => {
-    if (!namespace) {
-      throw new Error('no namespace provided')
-    }
-
-    return errorsAtom.set(({ errors }) => {
-      errors = errors || []
-      return {
-        // this array can be big. not sure about prefering spread operator here
-        // concat function seems like a better option
-        errors: [{ namespace, error, context, time: Date.now() }]
-          // eslint-disable-next-line unicorn/prefer-spread
-          .concat(errors)
-          .slice(0, maxErrorsCount),
-      }
-    })
-  }
-
-  return { track }
-}