feat: 2.7 Chore/sentry onboarding cp-7.52.0

app/actions/multiSrp/index.test.ts

@@ -8,6 +8,7 @@ import {
 } from './';
 import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';
 import { createMockInternalAccount } from '../../util/test/accountsControllerTestUtils';
+import { TraceName, TraceOperation } from '../../util/trace';
 import ReduxService from '../../core/redux/ReduxService';
 import { RootState } from '../../reducers';
 
@@ -28,6 +29,12 @@ const mockControllerMessenger = jest.fn();
 const mockAddDiscoveredAccounts = jest.fn();
 const mockGetAccountByAddress = jest.fn().mockReturnValue(mockExpectedAccount);
 
+// Mock for seedless onboarding
+const mockSelectSeedlessOnboardingLoginFlow = jest.fn();
+const mockAddNewSeedPhraseBackup = jest.fn();
+const mockTrace = jest.fn();
+const mockEndTrace = jest.fn();
+
 const hdKeyring = {
   getAccounts: () => {
     mockGetAccounts();
@@ -43,6 +50,17 @@ const mockSnapClient = {
   addDiscoveredAccounts: mockAddDiscoveredAccounts,
 };
 
+jest.mock('../../selectors/seedlessOnboardingController', () => ({
+  selectSeedlessOnboardingLoginFlow: (state: unknown) =>
+    mockSelectSeedlessOnboardingLoginFlow(state),
+}));
+
+jest.mock('../../util/trace', () => ({
+  ...jest.requireActual('../../util/trace'),
+  trace: (options: unknown) => mockTrace(options),
+  endTrace: (options: unknown) => mockEndTrace(options),
+}));
+
 const createMockState = (hasVault: boolean) => ({
   engine: {
     backgroundState: {
@@ -81,7 +99,8 @@ jest.mock('../../core/Engine', () => ({
       getAccountByAddress: () => mockGetAccountByAddress(),
     },
     SeedlessOnboardingController: {
-      addNewSeedPhraseBackup: jest.fn().mockResolvedValue(undefined),
+      addNewSeedPhraseBackup: (seed: Uint8Array, keyringId: string) =>
+        mockAddNewSeedPhraseBackup(seed, keyringId),
     },
   },
   setSelectedAddress: (address: string) => mockSetSelectedAddress(address),
@@ -103,7 +122,11 @@ describe('MultiSRP Actions', () => {
   describe('importNewSecretRecoveryPhrase', () => {
     it('imports new SRP', async () => {
       mockGetKeyringsByType.mockResolvedValue([]);
-      mockAddNewKeyring.mockResolvedValue({ getAccounts: () => [testAddress] });
+      mockAddNewKeyring.mockResolvedValue({
+        getAccounts: () => [testAddress],
+        id: 'keyring-id-123',
+      });
+      mockSelectSeedlessOnboardingLoginFlow.mockReturnValue(false);
 
       await importNewSecretRecoveryPhrase(testMnemonic);
 
@@ -131,7 +154,74 @@ describe('MultiSRP Actions', () => {
       expect(mockAddNewKeyring).not.toHaveBeenCalled();
     });
 
+    describe('seedless onboarding login flow', () => {
+      beforeEach(() => {
+        mockGetKeyringsByType.mockResolvedValue([]);
+        mockAddNewKeyring.mockResolvedValue({
+          getAccounts: () => [testAddress],
+          id: 'keyring-id-123',
+        });
+        mockSelectSeedlessOnboardingLoginFlow.mockReturnValue(true);
+      });
+
+      it('successfully adds seed phrase backup when seedless onboarding is enabled', async () => {
+        mockAddNewSeedPhraseBackup.mockResolvedValue(undefined);
+
+        const result = await importNewSecretRecoveryPhrase(testMnemonic);
+
+        expect(mockSelectSeedlessOnboardingLoginFlow).toHaveBeenCalled();
+        expect(mockTrace).toHaveBeenCalledWith({
+          name: TraceName.OnboardingAddSrp,
+          op: TraceOperation.OnboardingSecurityOp,
+        });
+        expect(mockAddNewSeedPhraseBackup).toHaveBeenCalledWith(
+          expect.any(Uint8Array),
+          'keyring-id-123',
+        );
+        expect(mockEndTrace).toHaveBeenCalledWith({
+          name: TraceName.OnboardingAddSrp,
+          data: { success: true },
+        });
+        expect(mockSetSelectedAddress).toHaveBeenCalledWith(testAddress);
+        expect(result.address).toBe(testAddress);
+        expect(mockAddDiscoveredAccounts).toHaveBeenCalled();
+      });
+
+      it('handles error when seed phrase backup fails and traces error', async () => {
+        mockAddNewSeedPhraseBackup.mockRejectedValue(
+          new Error('Backup failed'),
+        );
+
+        await expect(
+          async () => await importNewSecretRecoveryPhrase(testMnemonic),
+        ).rejects.toThrow('Backup failed');
+
+        expect(mockSelectSeedlessOnboardingLoginFlow).toHaveBeenCalled();
+        expect(mockTrace).toHaveBeenCalledWith({
+          name: TraceName.OnboardingAddSrp,
+          op: TraceOperation.OnboardingSecurityOp,
+        });
+        expect(mockAddNewSeedPhraseBackup).toHaveBeenCalledWith(
+          expect.any(Uint8Array),
+          'keyring-id-123',
+        );
+        expect(mockTrace).toHaveBeenCalledWith({
+          name: TraceName.OnboardingAddSrpError,
+          op: TraceOperation.OnboardingError,
+          tags: { errorMessage: 'Backup failed' },
+        });
+        expect(mockEndTrace).toHaveBeenCalledWith({
+          name: TraceName.OnboardingAddSrpError,
+        });
+        expect(mockEndTrace).toHaveBeenCalledWith({
+          name: TraceName.OnboardingAddSrp,
+          data: { success: false },
+        });
+      });
+    });
+
     it('calls addNewSeedPhraseBackup when seedless onboarding login flow is active', async () => {
+      mockAddNewSeedPhraseBackup.mockResolvedValue(undefined);
       mockGetKeyringsByType.mockResolvedValue([]);
       mockAddNewKeyring.mockResolvedValue({
         id: 'test-keyring-id',
@@ -144,9 +234,10 @@ describe('MultiSRP Actions', () => {
 
       await importNewSecretRecoveryPhrase(testMnemonic);
 
-      expect(
-        Engine.context.SeedlessOnboardingController.addNewSeedPhraseBackup,
-      ).toHaveBeenCalledWith(expect.any(Uint8Array), 'test-keyring-id');
+      expect(mockAddNewSeedPhraseBackup).toHaveBeenCalledWith(
+        expect.any(Uint8Array),
+        'test-keyring-id',
+      );
     });
   });
 

app/actions/multiSrp/index.ts

@@ -16,10 +16,10 @@ import {
 } from '../../core/redux/slices/performance';
 import { PerformanceEventNames } from '../../core/redux/slices/performance/constants';
 import { store } from '../../store';
-import { endTrace, trace, TraceName, TraceOperation } from '../../util/trace';
 import { getTraceTags } from '../../util/sentry/tags';
 
 import ReduxService from '../../core/redux';
+import { TraceName, TraceOperation, trace, endTrace } from '../../util/trace';
 import { selectSeedlessOnboardingLoginFlow } from '../../selectors/seedlessOnboardingController';
 
 export async function importNewSecretRecoveryPhrase(mnemonic: string) {
@@ -72,24 +72,48 @@ export async function importNewSecretRecoveryPhrase(mnemonic: string) {
 
   const { SeedlessOnboardingController } = Engine.context;
 
+  let discoveredAccountsCount = 0;
+
   // TODO: to use loginCompleted
   if (selectSeedlessOnboardingLoginFlow(ReduxService.store.getState())) {
     // on Error, wallet should notify user that the newly added seed phrase is not synced properly
     // user can try manual sync again (phase 2)
     const seed = new Uint8Array(inputCodePoints.buffer);
+    let addSeedPhraseSuccess = false;
     try {
+      trace({
+        name: TraceName.OnboardingAddSrp,
+        op: TraceOperation.OnboardingSecurityOp,
+      });
       await SeedlessOnboardingController.addNewSeedPhraseBackup(
         seed,
         newKeyring.id,
       );
+      addSeedPhraseSuccess = true;
     } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : 'Unknown error';
       // Log the error but don't let it crash the import process
-      console.error('Failed to backup seed phrase:', error);
+      console.error('Failed to backup seed phrase:', errorMessage);
+
+      trace({
+        name: TraceName.OnboardingAddSrpError,
+        op: TraceOperation.OnboardingError,
+        tags: { errorMessage },
+      });
+      endTrace({
+        name: TraceName.OnboardingAddSrpError,
+      });
+
+      throw error;
+    } finally {
+      endTrace({
+        name: TraceName.OnboardingAddSrp,
+        data: { success: addSeedPhraseSuccess },
+      });
     }
   }
 
-  let discoveredAccountsCount = 0;
-
   ///: BEGIN:ONLY_INCLUDE_IF(solana)
   const multichainClient = MultichainWalletSnapFactory.createClient(
     WalletClientType.Solana,

app/components/UI/OptinMetrics/index.js

@@ -51,6 +51,12 @@ import Icon, {
   IconColor,
 } from '../../../component-library/components/Icons/Icon';
 import { getConfiguredCaipChainIds } from '../../../util/metrics/MultichainAPI/networkMetricUtils';
+import {
+  updateCachedConsent,
+  flushBufferedTraces,
+  discardBufferedTraces,
+} from '../../../util/trace';
+import { setupSentry } from '../../../util/sentry/utils';
 
 const createStyles = ({ colors }) =>
   StyleSheet.create({
@@ -330,6 +336,9 @@ class OptinMetrics extends PureComponent {
       // and disable analytics
       clearOnboardingEvents();
       await metrics.enable(false);
+      await setupSentry(); // Re-setup Sentry with enabled: false
+      discardBufferedTraces();
+      updateCachedConsent(false);
     }, 200);
     this.continue();
   };
@@ -346,6 +355,10 @@ class OptinMetrics extends PureComponent {
     } = this.props;
 
     await metrics.enable();
+    await setupSentry(); // Re-setup Sentry with enabled: true
+    await flushBufferedTraces();
+    updateCachedConsent(true);
+
     // Handle null case for marketing consent
     if (
       isDataCollectionForMarketingEnabled === null &&

app/components/Views/AccountBackupStep1/index.js

@@ -45,6 +45,7 @@ import Icon, {
 import { CommonActions, useNavigation } from '@react-navigation/native';
 import { useMetrics } from '../../hooks/useMetrics';
 import { ONBOARDING_SUCCESS_FLOW } from '../../../constants/onboarding';
+import { TraceName, endTrace } from '../../../util/trace';
 
 const createStyles = (colors) =>
   StyleSheet.create({
@@ -114,6 +115,7 @@ const AccountBackupStep1 = (props) => {
   const [hasFunds, setHasFunds] = useState(false);
   const { colors } = useTheme();
   const styles = createStyles(colors);
+  const { isEnabled: isMetricsEnabled } = useMetrics();
 
   const track = (event, properties) => {
     const eventBuilder = MetricsEventBuilder.createEventBuilder(event);
@@ -175,7 +177,6 @@ const AccountBackupStep1 = (props) => {
     track(MetaMetricsEvents.WALLET_SECURITY_STARTED);
   };
 
-  const { isEnabled: isMetricsEnabled } = useMetrics();
   const skip = async () => {
     track(MetaMetricsEvents.WALLET_SECURITY_SKIP_CONFIRMED);
     // Get onboarding wizard state
@@ -197,6 +198,9 @@ const AccountBackupStep1 = (props) => {
         },
       ],
     });
+    endTrace({ name: TraceName.OnboardingNewSrpCreateWallet });
+    endTrace({ name: TraceName.OnboardingJourneyOverall });
+
     if (isMetricsEnabled()) {
       navigation.dispatch(resetAction);
     } else {

app/components/Views/AccountStatus/index.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 import {
   View,
   Image,
@@ -29,6 +29,14 @@ import { MetaMetricsEvents } from '../../../core/Analytics/MetaMetrics.events';
 import { PREVIOUS_SCREEN } from '../../../constants/navigation';
 import { MetricsEventBuilder } from '../../../core/Analytics/MetricsEventBuilder';
 import trackOnboarding from '../../../util/metrics/TrackOnboarding/trackOnboarding';
+import {
+  endTrace,
+  trace,
+  TraceName,
+  TraceOperation,
+} from '../../../util/trace';
+import { getTraceTags } from '../../../util/sentry/tags';
+import { store } from '../../../store';
 import {
   IMetaMetricsEvent,
   ITrackingEvent,
@@ -37,7 +45,6 @@ import {
   OnboardingActionTypes,
   saveOnboardingEvent as saveEvent,
 } from '../../../actions/onboarding';
-
 import AccountStatusImg from '../../../images/account_status.png';
 
 interface AccountStatusProps {
@@ -48,6 +55,7 @@ interface AccountStatusProps {
 interface AccountRouteParams {
   accountName?: string;
   oauthLoginSuccess?: boolean;
+  onboardingTraceCtx?: string;
 }
 
 const AccountStatus = ({
@@ -60,6 +68,8 @@ const AccountStatus = ({
   const accountName = (route.params as AccountRouteParams)?.accountName;
   const oauthLoginSuccess = (route.params as AccountRouteParams)
     ?.oauthLoginSuccess;
+  const onboardingTraceCtx = (route.params as AccountRouteParams)
+    ?.onboardingTraceCtx;
 
   // check for small screen size
   const isSmallScreen = Dimensions.get('window').width < 375;
@@ -71,15 +81,47 @@ const AccountStatus = ({
     );
   };
 
+  useEffect(() => {
+    const traceName =
+      type === 'found'
+        ? TraceName.OnboardingNewSocialAccountExists
+        : TraceName.OnboardingExistingSocialAccountNotFound;
+
+    trace({
+      name: traceName,
+      op: TraceOperation.OnboardingUserJourney,
+      tags: getTraceTags(store.getState()),
+      parentContext: onboardingTraceCtx,
+    });
+    return () => {
+      endTrace({ name: traceName });
+    };
+  }, [onboardingTraceCtx, type]);
+
   const navigateNextScreen = (
     targetRoute: string,
     previousScreen: string,
     metricEvent: string,
   ) => {
+    const nextScenarioTraceName =
+      type === 'found'
+        ? TraceName.OnboardingExistingSocialLogin
+        : TraceName.OnboardingNewSocialCreateWallet;
+    trace({
+      name: nextScenarioTraceName,
+      op: TraceOperation.OnboardingUserJourney,
+      tags: {
+        ...getTraceTags(store.getState()),
+        source: 'account_status_redirect',
+      },
+      parentContext: onboardingTraceCtx,
+    });
+
     navigation.dispatch(
       StackActions.replace(targetRoute, {
         [PREVIOUS_SCREEN]: previousScreen,
         oauthLoginSuccess,
+        onboardingTraceCtx,
       }),
     );
     track(