Merge pull request #1875 from jetstreamapp/fix/error-tracker-fixes

fix: enhance error tracking and handling for Salesforce API interactions

Author: paustint

apps/api/src/app/utils/response.handlers.ts

@@ -166,6 +166,7 @@ export async function uncaughtErrorHandler(err: any, req: express.Request, res:
       sfdcErrorMessage === ERROR_MESSAGES.SFDC_EXPIRED_TOKEN ||
       sfdcErrorMessage === ERROR_MESSAGES.SFDC_EXPIRED_SESSION ||
       sfdcErrorMessage === ERROR_MESSAGES.SFDC_EXPIRED_TOKEN_VALIDITY ||
+      sfdcErrorMessage === ERROR_MESSAGES.SFDC_INVALID_SESSION_ID ||
       ERROR_MESSAGES.SFDC_ORG_DOES_NOT_EXIST.test(sfdcErrorMessage);
     const isSfdcRestApiNotEnabled = ERROR_MESSAGES.SFDC_REST_API_NOT_ENABLED.test(sfdcErrorMessage);
     // Salesforce reports the same auth failure with different HTTP statuses depending on the API (REST is

libs/features/automation-control/src/useAutomationControlData.ts

@@ -751,7 +751,9 @@ export function useAutomationControlData({
             dispatch({ type: 'FETCH_SUCCESS', payload: item });
           } else {
             dispatch({ type: 'FETCH_ERROR', payload: item });
-            tracker.error('Automation Control Fetch Error', { item });
+            // Pass the underlying error as an Error so distinct causes get distinct fingerprints and the
+            // tracker's ignore list (e.g. expired-token noise) can match it — extras are not inspected.
+            tracker.error('Automation Control Fetch Error', new Error(item.error), { item });
           }
         },
         error: (err) => {

libs/features/load-records/src/components/load-mapping-storage/LoadMappingPopover.tsx

@@ -3,7 +3,7 @@ import { logger } from '@jetstream/shared/client-logger';
 import { LoadSavedMappingItem } from '@jetstream/types';
 import { BadgeNotification, EmptyState, fireToast, Icon, Popover, PopoverRef } from '@jetstream/ui';
 import { STATIC_MAPPING_PREFIX } from '@jetstream/ui-core';
-import { dexieDb } from '@jetstream/ui/db';
+import { dexieDb, withReopenOnDatabaseClosed } from '@jetstream/ui/db';
 import classNames from 'classnames';
 import { useLiveQuery } from 'dexie-react-hooks';
 import { FunctionComponent, useRef } from 'react';
@@ -46,10 +46,10 @@ export const LoadMappingPopover: FunctionComponent<LoadMappingPopoverProps> = ({
     }
   }
 
-  function handleButtonAction(id: string, metadata: LoadSavedMappingItem) {
+  async function handleButtonAction(id: string, metadata: LoadSavedMappingItem) {
     try {
       if (id === 'delete' && metadata) {
-        dexieDb.load_saved_mapping.where('key').equals(metadata.key).delete();
+        await withReopenOnDatabaseClosed(() => dexieDb.load_saved_mapping.where('key').equals(metadata.key).delete());
       }
     } catch (ex) {
       logger.warn('Failed to delete field mapping', ex);

libs/features/load-records/src/components/load-mapping-storage/SaveMappingPopover.tsx

@@ -1,9 +1,10 @@
 import { css } from '@emotion/react';
+import { logger } from '@jetstream/shared/client-logger';
 import { formatNumber } from '@jetstream/shared/ui-utils';
 import { pluralizeIfMultiple } from '@jetstream/shared/utils';
 import { FieldMapping, LoadSavedMappingItem } from '@jetstream/types';
-import { Grid, Icon, Input, Popover, PopoverRef, ScopedNotification } from '@jetstream/ui';
-import { dexieDb, getHashedRecordKey } from '@jetstream/ui/db';
+import { fireToast, Grid, Icon, Input, Popover, PopoverRef, ScopedNotification } from '@jetstream/ui';
+import { dexieDb, getHashedRecordKey, withReopenOnDatabaseClosed } from '@jetstream/ui/db';
 import { formatISO } from 'date-fns/formatISO';
 import omit from 'lodash/omit';
 import { FunctionComponent, useEffect, useMemo, useRef, useState } from 'react';
@@ -55,14 +56,24 @@ export const SaveMappingPopover: FunctionComponent<SaveMappingPopoverProps> = ({
   }, [fieldMapping, sobject]);
 
   async function handleSave() {
-    const newMapping: LoadSavedMappingItem = { ...currentSavedMapping, name: mappingName };
-    newMapping.createdAt = new Date();
-    newMapping.key = `lsm_${sobject}:${newMapping.csvFields.length}:${formatISO(newMapping.createdAt).toLowerCase()}`;
-    newMapping.hashedKey = await getHashedRecordKey(newMapping.key);
-    dexieDb.load_saved_mapping.put(newMapping);
-    saveSetMappingName('');
-    setCurrentSavedMapping(getDefaultItem(sobject));
-    popoverRef.current?.close();
+    try {
+      const newMapping: LoadSavedMappingItem = { ...currentSavedMapping, name: mappingName };
+      newMapping.createdAt = new Date();
+      newMapping.key = `lsm_${sobject}:${newMapping.csvFields.length}:${formatISO(newMapping.createdAt).toLowerCase()}`;
+      newMapping.hashedKey = await getHashedRecordKey(newMapping.key);
+      await withReopenOnDatabaseClosed(() => dexieDb.load_saved_mapping.put(newMapping));
+      saveSetMappingName('');
+      setCurrentSavedMapping(getDefaultItem(sobject));
+      popoverRef.current?.close();
+    } catch (ex) {
+      // The awaited Dexie write can reject; handleSave is called fire-and-forget from onSubmit, so catch
+      // here to avoid an unhandled rejection and give the user feedback (popover stays open to retry).
+      logger.warn('Failed to save field mapping', ex);
+      fireToast({
+        type: 'error',
+        message: 'Uh oh, there was a problem saving the field mapping. Please try again.',
+      });
+    }
   }
 
   return (

libs/features/load-records/src/components/load-results/LoadRecordsBulkApiResults.tsx

@@ -462,7 +462,11 @@ export const LoadRecordsBulkApiResults = ({
         body: `❌ ${getErrorMessage(ex)}`,
         tag: 'load-records',
       });
-      tracker.error('Error preparing bulk api data', ex);
+      // A user-initiated abort throws 'Aborted' through this same path — keep the UI messaging but
+      // don't report it as an application error.
+      if (!isAborted.current) {
+        tracker.error('Error preparing bulk api data', ex);
+      }
       return;
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -516,12 +520,19 @@ export const LoadRecordsBulkApiResults = ({
             tag: 'load-records',
           });
         }
-        tracker.error('Error loading batches', loadError, {
-          specificErrors: loadError.additionalErrors.map((error) => ({
-            message: error.message,
-            stack: error.stack,
-          })),
-        });
+        // A user-initiated abort surfaces through the same loadError path — keep the UI messaging but
+        // don't report it as an application error unless some batch failed for a non-abort reason.
+        const abortMessagePattern = /aborted by user|data load was aborted|current job state is 'Aborted'/i;
+        const onlyUserAbortErrors =
+          loadError.additionalErrors.length > 0 && loadError.additionalErrors.every((error) => abortMessagePattern.test(error.message));
+        if (!onlyUserAbortErrors) {
+          tracker.error('Error loading batches', loadError, {
+            specificErrors: loadError.additionalErrors.map((error) => ({
+              message: error.message,
+              stack: error.stack,
+            })),
+          });
+        }
       } else {
         setJobInfo(jobInfo);
         setStatus(STATUSES.PROCESSING);

libs/features/load-records/src/utils/__tests__/load-records-process.spec.ts

@@ -1,11 +1,49 @@
-import { MAX_CONSECUTIVE_FAILURES, isFatalBulkApiError } from '../load-records-process';
+import { MAX_BATCH_CSV_CHARS, MAX_CONSECUTIVE_FAILURES, generateSizeCappedBatchCsvs, isFatalBulkApiError } from '../load-records-process';
 
 describe('MAX_CONSECUTIVE_FAILURES', () => {
   it('should equal 5', () => {
     expect(MAX_CONSECUTIVE_FAILURES).toBe(5);
   });
 });
 
+describe('generateSizeCappedBatchCsvs', () => {
+  it('splits by record count when all batches are within the size cap', () => {
+    const records = Array.from({ length: 10 }, (_, i) => ({ Id: `rec-${i}`, Name: `Record ${i}` }));
+
+    const csvs = generateSizeCappedBatchCsvs(records, 3);
+
+    expect(csvs).toHaveLength(4);
+    // Every record lands in exactly one batch and each batch repeats the header
+    records.forEach(({ Id }) => {
+      expect(csvs.filter((csv) => csv.includes(Id))).toHaveLength(1);
+    });
+    csvs.forEach((csv) => expect(csv.startsWith('Id')).toBe(true));
+  });
+
+  it('halves batches whose CSV exceeds the character cap', () => {
+    // 8 records x ~2M chars each = ~16M chars in one count-based batch, which must split into two
+    const bigValue = 'x'.repeat(2_000_000);
+    const records = Array.from({ length: 8 }, (_, i) => ({ Id: `rec-${i}`, Description: bigValue }));
+
+    const csvs = generateSizeCappedBatchCsvs(records, 8);
+
+    expect(csvs.length).toBeGreaterThan(1);
+    csvs.forEach((csv) => expect(csv.length).toBeLessThanOrEqual(MAX_BATCH_CSV_CHARS));
+    records.forEach(({ Id }) => {
+      expect(csvs.filter((csv) => csv.includes(`${Id},`))).toHaveLength(1);
+    });
+  });
+
+  it('passes through a single record that alone exceeds the cap', () => {
+    const records = [{ Id: 'rec-0', Description: 'x'.repeat(MAX_BATCH_CSV_CHARS + 100) }];
+
+    const csvs = generateSizeCappedBatchCsvs(records, 100);
+
+    expect(csvs).toHaveLength(1);
+    expect(csvs[0].length).toBeGreaterThan(MAX_BATCH_CSV_CHARS);
+  });
+});
+
 describe('isFatalBulkApiError', () => {
   describe('fatal error patterns', () => {
     it('should detect ApiBatchItems Limit exceeded', () => {

libs/features/load-records/src/utils/load-records-process.ts

@@ -69,11 +69,34 @@ export const FATAL_BULK_ERROR_PATTERNS: ReadonlyArray<RegExp> = Object.freeze([
 
 export const MAX_CONSECUTIVE_FAILURES = 5;
 
+// Salesforce Bulk API v1 rejects any batch CSV over 10,000,000 characters ("Failed to read request.
+// Exceeded max size limit of 10000000"). Batching is by record count, so wide rows can blow the cap
+// even at modest batch sizes. Kept below the hard limit for encoding/newline headroom.
+export const MAX_BATCH_CSV_CHARS = 9_500_000;
+
 export function isFatalBulkApiError(error: unknown): boolean {
   const message = getErrorMessage(error);
   return FATAL_BULK_ERROR_PATTERNS.some((pattern) => pattern.test(message));
 }
 
+/**
+ * Generate batch CSVs capped both by record count and by CSV character count. A batch whose CSV
+ * exceeds `MAX_BATCH_CSV_CHARS` is recursively halved until it fits; a single record that alone
+ * exceeds the cap is passed through as-is (Salesforce rejects it with a per-batch error, same as today).
+ */
+export function generateSizeCappedBatchCsvs(records: unknown[], batchSize: number): string[] {
+  return splitArrayToMaxSize(records, batchSize).flatMap(csvForBatchRecords);
+}
+
+function csvForBatchRecords(batchRecords: unknown[]): string[] {
+  const csv = generateCsv(batchRecords, { delimiter: ',' });
+  if (csv.length <= MAX_BATCH_CSV_CHARS || batchRecords.length <= 1) {
+    return [csv];
+  }
+  const midpoint = Math.ceil(batchRecords.length / 2);
+  return [...csvForBatchRecords(batchRecords.slice(0, midpoint)), ...csvForBatchRecords(batchRecords.slice(midpoint))];
+}
+
 /**
  * Load data using the BULK API
  *
@@ -91,9 +114,7 @@ export async function loadBulkApiData(
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const jobId = results.id!;
     let batches: LoadDataBulkApi[] = [];
-    batches = splitArrayToMaxSize(data, batchSize)
-      .map((batch) => generateCsv(batch, { delimiter: ',' }))
-      .map((data, i) => ({ data, batchNumber: i, completed: false, success: false }));
+    batches = generateSizeCappedBatchCsvs(data, batchSize).map((data, i) => ({ data, batchNumber: i, completed: false, success: false }));
 
     let submittedBatchCount = 0;
 

libs/features/manage-permissions/src/usePermissionRecords.tsx

@@ -138,8 +138,8 @@ export function usePermissionRecords(selectedOrg: SalesforceOrgUi, sobjects: str
         setSystemPermissionMap(output.systemPermissionMap);
       }
     } catch (ex) {
-      logger.warn('[useProfilesAndPermSets][ERROR]', getErrorMessage(ex));
-      tracker.error('[useProfilesAndPermSets][ERROR]', ex);
+      logger.warn('[usePermissionRecords][ERROR]', getErrorMessage(ex));
+      tracker.error('[usePermissionRecords][ERROR]', ex);
       if (isMounted.current) {
         setHasError(true);
       }

libs/features/manage-permissions/src/utils/permission-manager-table-utils.tsx

@@ -583,7 +583,7 @@ export function getFieldColumns(
           permissionType: 'field',
           id: profileId,
           type: 'Profile',
-          label: profile.Profile.Name,
+          label: profile?.Profile?.Name || '',
           actionType: startCase(permissionType) as 'Read' | 'Edit',
           actionKey: permissionType,
         }),
@@ -986,7 +986,7 @@ export function getTabVisibilityColumns(
           permissionType: 'tabVisibility',
           id: profileId,
           type: 'Profile',
-          label: profile.Profile.Name,
+          label: profile?.Profile?.Name || '',
           actionType: startCase(actionKey) as 'Available' | 'Visible',
           actionKey,
         }),

libs/features/salesforce-api/src/SalesforceApi.tsx

@@ -63,7 +63,7 @@ export const SalesforceApi: FunctionComponent<SalesforceApiProps> = () => {
           })
           .catch((ex) => {
             logger.warn('[ERROR] Could not save history', ex);
-            tracker.error('Error saving apex history', ex);
+            tracker.error('Error saving API request history', ex);
           });
       } catch (ex) {
         setResults({