feat: integrate error tracking service with RPC handlers

packages/gator-permissions-snap/src/index.ts

@@ -1,5 +1,9 @@
 /* eslint-disable no-restricted-globals */
-import { logger } from '@metamask/7715-permissions-shared/utils';
+import {
+  logger,
+  createErrorTracker,
+  getErrorTracker,
+} from '@metamask/7715-permissions-shared/utils';
 import {
   AuthType,
   JwtBearerAuth,
@@ -190,6 +194,12 @@ const rpcHandler = createRpcHandler({
   blockchainMetadataClient: tokenMetadataClient,
 });
 
+// Initialize error tracker
+createErrorTracker({
+  enabled: true,
+  snapName: 'gator-permissions-snap',
+});
+
 // configure RPC methods bindings
 const boundRpcHandlers: {
   [RpcMethod: string]: (params?: JsonRpcParams) => Promise<Json>;
@@ -221,27 +231,36 @@ export const onRpcRequest: OnRpcRequestHandler = async ({
   origin,
   request,
 }) => {
-  logger.debug(`RPC request (origin="${origin}"): method="${request.method}"`);
-
-  // Ensure i18n is initialized on every snap invocation
-  // This handles both initial load and locale changes in the extension
-  await setupI18n();
+  const errorTracker = getErrorTracker();
 
-  if (!isMethodAllowedForOrigin(origin, request.method)) {
-    throw new InvalidRequestError(
-      `Origin '${origin}' is not allowed to call '${request.method}'`,
+  try {
+    logger.debug(
+      `RPC request (origin="${origin}"): method="${request.method}"`,
     );
-  }
 
-  const handler = boundRpcHandlers[request.method];
+    // Ensure i18n is initialized on every snap invocation
+    // This handles both initial load and locale changes in the extension
+    await setupI18n();
 
-  if (!handler) {
-    throw new MethodNotFoundError(`Method ${request.method} not found.`);
-  }
+    if (!isMethodAllowedForOrigin(origin, request.method)) {
+      throw new InvalidRequestError(
+        `Origin '${origin}' is not allowed to call '${request.method}'`,
+      );
+    }
+
+    const handler = boundRpcHandlers[request.method];
 
-  const result = await handler(request.params);
+    if (!handler) {
+      throw new MethodNotFoundError(`Method ${request.method} not found.`);
+    }
 
-  return result;
+    const result = await handler(request.params);
+
+    return result;
+  } catch (error) {
+    await errorTracker.captureError(error, request.method);
+    throw error;
+  }
 };
 
 /**

packages/gator-permissions-snap/src/rpc/rpcErrorHandler.ts

@@ -0,0 +1,67 @@
+/**
+ * RPC Error Handler Wrapper
+ *
+ * This module demonstrates how to integrate the error tracking service
+ * with RPC request handlers to capture and monitor errors in snap operations.
+ */
+
+import { getErrorTracker } from '@metamask/7715-permissions-shared/utils';
+import type { Json, JsonRpcParams } from '@metamask/snaps-sdk';
+
+type RpcHandler = (params?: JsonRpcParams) => Promise<Json>;
+
+/**
+ * Wraps an RPC handler with error tracking.
+ * Captures any errors that occur during RPC execution while maintaining
+ * the original error flow.
+ *
+ * @param handler - The original RPC handler function.
+ * @param methodName - The RPC method name (for error tracking).
+ * @returns A wrapped RPC handler with error tracking.
+ */
+export function wrapRpcHandlerWithErrorTracking(
+  handler: RpcHandler,
+  methodName: string,
+): RpcHandler {
+  return async (params?: JsonRpcParams): Promise<Json> => {
+    const errorTracker = getErrorTracker();
+
+    try {
+      const result = await handler(params);
+
+      // Check if response indicates an error (even with 200 status)
+      if (
+        result &&
+        typeof result === 'object' &&
+        'error' in result &&
+        (result as any).error
+      ) {
+        await errorTracker.captureResponseError(result, methodName);
+      }
+
+      return result;
+    } catch (error) {
+      await errorTracker.captureError(error, methodName);
+      throw error;
+    }
+  };
+}
+
+/**
+ * Higher-order function to create multiple wrapped RPC handlers at once.
+ * Useful for wrapping all RPC handlers in a batch operation.
+ *
+ * @param handlers - An object mapping method names to RPC handler functions.
+ * @returns An object with wrapped handlers.
+ */
+export function wrapRpcHandlersWithErrorTracking(
+  handlers: Record<string, RpcHandler>,
+): Record<string, RpcHandler> {
+  const wrapped: Record<string, RpcHandler> = {};
+
+  for (const [methodName, handler] of Object.entries(handlers)) {
+    wrapped[methodName] = wrapRpcHandlerWithErrorTracking(handler, methodName);
+  }
+
+  return wrapped;
+}

packages/permissions-kernel-snap/src/index.ts

@@ -1,4 +1,8 @@
-import { logger } from '@metamask/7715-permissions-shared/utils';
+import {
+  logger,
+  createErrorTracker,
+  getErrorTracker,
+} from '@metamask/7715-permissions-shared/utils';
 import {
   InvalidParamsError,
   LimitExceededError,
@@ -19,6 +23,12 @@ const rpcHandler = createRpcHandler({
   snapsProvider: snap,
 });
 
+// Initialize error tracker
+createErrorTracker({
+  enabled: true,
+  snapName: 'permissions-kernel-snap',
+});
+
 // configure RPC methods bindings
 const boundRpcHandlers: {
   [RpcMethod: string]: (options: {
@@ -52,6 +62,8 @@ export const onRpcRequest: OnRpcRequestHandler = async ({
   origin,
   request,
 }) => {
+  const errorTracker = getErrorTracker();
+
   // Check if another request is already being processed
   if (activeProcessingLock !== null) {
     logger.warn(
@@ -101,6 +113,9 @@ export const onRpcRequest: OnRpcRequestHandler = async ({
     });
 
     return result;
+  } catch (error) {
+    await errorTracker.captureError(error, request.method || 'unknown');
+    throw error;
   } finally {
     // Always release the processing lock we acquired, regardless of success or failure
     // Only release if we still hold the lock to avoid clobbering a newer lock

packages/permissions-kernel-snap/src/rpc/rpcErrorHandler.ts

@@ -0,0 +1,72 @@
+/**
+ * RPC Error Handler Wrapper
+ *
+ * This module demonstrates how to integrate the error tracking service
+ * with RPC request handlers to capture and monitor errors in snap operations.
+ */
+
+import { getErrorTracker } from '@metamask/7715-permissions-shared/utils';
+import type { Json, JsonRpcParams } from '@metamask/snaps-sdk';
+
+type RpcHandlerOptions = {
+  siteOrigin: string;
+  params?: JsonRpcParams;
+};
+
+type RpcHandler = (options: RpcHandlerOptions) => Promise<Json>;
+
+/**
+ * Wraps an RPC handler with error tracking.
+ * Captures any errors that occur during RPC execution while maintaining
+ * the original error flow.
+ *
+ * @param handler - The original RPC handler function.
+ * @param methodName - The RPC method name (for error tracking).
+ * @returns A wrapped RPC handler with error tracking.
+ */
+export function wrapRpcHandlerWithErrorTracking(
+  handler: RpcHandler,
+  methodName: string,
+): RpcHandler {
+  return async (options: RpcHandlerOptions): Promise<Json> => {
+    const errorTracker = getErrorTracker();
+
+    try {
+      const result = await handler(options);
+
+      // Check if response indicates an error (even with 200 status)
+      if (
+        result &&
+        typeof result === 'object' &&
+        'error' in result &&
+        (result as any).error
+      ) {
+        await errorTracker.captureResponseError(result, methodName);
+      }
+
+      return result;
+    } catch (error) {
+      await errorTracker.captureError(error, methodName);
+      throw error;
+    }
+  };
+}
+
+/**
+ * Higher-order function to create multiple wrapped RPC handlers at once.
+ * Useful for wrapping all RPC handlers in a batch operation.
+ *
+ * @param handlers - An object mapping method names to RPC handler functions.
+ * @returns An object with wrapped handlers.
+ */
+export function wrapRpcHandlersWithErrorTracking(
+  handlers: Record<string, RpcHandler>,
+): Record<string, RpcHandler> {
+  const wrapped: Record<string, RpcHandler> = {};
+
+  for (const [methodName, handler] of Object.entries(handlers)) {
+    wrapped[methodName] = wrapRpcHandlerWithErrorTracking(handler, methodName);
+  }
+
+  return wrapped;
+}

packages/shared/package.json

@@ -12,7 +12,8 @@
     "./utils": "./src/utils/index.ts",
     "./types": "./src/types/index.ts",
     "./constants": "./src/constants/index.ts",
-    "./testing": "./src/testing/index.ts"
+    "./testing": "./src/testing/index.ts",
+    "./error-tracking": "./src/utils/errorTracking.ts"
   },
   "main": "./src",
   "types": "./src",
@@ -28,6 +29,7 @@
     "test": "jest"
   },
   "dependencies": {
+    "@metamask/snaps-sdk": "10.2.0",
     "@metamask/utils": "11.4.2",
     "dotenv": "17.2.0",
     "zod": "3.25.76"