diff --git a/CHANGELOG.md b/CHANGELOG.md
index a2c7d99cc5..7e7280c61c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Features
 
 - Add User Interaction Tracing for Touch events ([#2835](https://github.com/getsentry/sentry-react-native/pull/2835))
+- Add Gesture Tracing for React Native Gesture Handler API v2 ([#2865](https://github.com/getsentry/sentry-react-native/pull/2865))
 
 ### Fixes
 
diff --git a/sample-new-architecture/src/App.tsx b/sample-new-architecture/src/App.tsx
index 4eae3b5ba1..f450accd5c 100644
--- a/sample-new-architecture/src/App.tsx
+++ b/sample-new-architecture/src/App.tsx
@@ -16,6 +16,9 @@ import PerformanceTimingScreen from './Screens/PerformanceTimingScreen';
 import ReduxScreen from './Screens/ReduxScreen';
 import { Provider } from 'react-redux';
 import { store } from './reduxApp';
+import { GestureHandlerRootView } from 'react-native-gesture-handler';
+import GesturesTracingScreen from './Screens/GesturesTracingScreen';
+import { StyleSheet } from 'react-native';
 
 const reactNavigationInstrumentation =
   new Sentry.ReactNavigationInstrumentation({
@@ -76,27 +79,39 @@ const App = () => {
   const navigation = React.useRef<NavigationContainerRef<{}>>(null);
 
   return (
-    <Provider store={store}>
-      <NavigationContainer
-        ref={navigation}
-        onReady={() => {
-          reactNavigationInstrumentation.registerNavigationContainer(
-            navigation,
-          );
-        }}>
-        <Stack.Navigator>
-          <Stack.Screen name="Home" component={HomeScreen} />
-          <Stack.Screen name="Tracker" component={TrackerScreen} />
-          <Stack.Screen name="ManualTracker" component={ManualTrackerScreen} />
-          <Stack.Screen
-            name="PerformanceTiming"
-            component={PerformanceTimingScreen}
-          />
-          <Stack.Screen name="Redux" component={ReduxScreen} />
-        </Stack.Navigator>
-      </NavigationContainer>
-    </Provider>
+    <GestureHandlerRootView style={styles.wrapper}>
+      <Provider store={store}>
+        <NavigationContainer
+          ref={navigation}
+          onReady={() => {
+            reactNavigationInstrumentation.registerNavigationContainer(
+              navigation,
+            );
+          }}>
+          <Stack.Navigator>
+            <Stack.Screen name="Home" component={HomeScreen} />
+            <Stack.Screen name="Tracker" component={TrackerScreen} />
+            <Stack.Screen
+              name="ManualTracker"
+              component={ManualTrackerScreen}
+            />
+            <Stack.Screen
+              name="PerformanceTiming"
+              component={PerformanceTimingScreen}
+            />
+            <Stack.Screen name="Redux" component={ReduxScreen} />
+            <Stack.Screen name="Gestures" component={GesturesTracingScreen} />
+          </Stack.Navigator>
+        </NavigationContainer>
+      </Provider>
+    </GestureHandlerRootView>
   );
 };
 
+const styles = StyleSheet.create({
+  wrapper: {
+    flex: 1,
+  },
+});
+
 export default Sentry.wrap(App);
diff --git a/sample-new-architecture/src/Screens/GesturesTracingScreen.tsx b/sample-new-architecture/src/Screens/GesturesTracingScreen.tsx
new file mode 100644
index 0000000000..650a029d7a
--- /dev/null
+++ b/sample-new-architecture/src/Screens/GesturesTracingScreen.tsx
@@ -0,0 +1,37 @@
+import React from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+import { Gesture, GestureDetector } from 'react-native-gesture-handler';
+import { getCurrentHub, Scope, sentryTraceGesture } from '@sentry/react-native';
+
+const GesturesTracingScreen = () => {
+  const gesture = Gesture.Pinch().onBegin(() => {
+    startExampleSpan();
+  });
+
+  return (
+    <GestureDetector gesture={sentryTraceGesture('pinch', gesture)}>
+      <View style={styles.screen}>
+        <Text>Do pinch gesture</Text>
+      </View>
+    </GestureDetector>
+  );
+};
+
+const startExampleSpan = () => {
+  getCurrentHub().withScope((scope: Scope) => {
+    const child = scope.getTransaction()?.startChild({ op: 'example' });
+    setTimeout(() => {
+      child?.finish();
+    }, 1000);
+  });
+};
+
+const styles = StyleSheet.create({
+  screen: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+});
+
+export default GesturesTracingScreen;
diff --git a/sample-new-architecture/src/Screens/HomeScreen.tsx b/sample-new-architecture/src/Screens/HomeScreen.tsx
index 4f370947e8..b23cbfb401 100644
--- a/sample-new-architecture/src/Screens/HomeScreen.tsx
+++ b/sample-new-architecture/src/Screens/HomeScreen.tsx
@@ -168,6 +168,12 @@ const HomeScreen = (props: Props) => {
             props.navigation.navigate('ManualTracker');
           }}
         />
+        <Button
+          title="Gestures Tracing Example"
+          onPress={() => {
+            props.navigation.navigate('Gestures');
+          }}
+        />
         <Button title="Performance Timing" onPress={onPressPerformanceTiming} />
         <Button
           title="Redux Example"
diff --git a/src/js/index.ts b/src/js/index.ts
index 8c909fc0f8..893d0e389d 100644
--- a/src/js/index.ts
+++ b/src/js/index.ts
@@ -82,6 +82,7 @@ export {
   ReactNativeNavigationInstrumentation,
   RoutingInstrumentation,
   ReactNavigationTransactionContext,
+  sentryTraceGesture,
 } from './tracing';
 
 export { Integrations, SDK_NAME, SDK_VERSION };
diff --git a/src/js/touchevents.tsx b/src/js/touchevents.tsx
index 24d1005fad..fa58273baf 100644
--- a/src/js/touchevents.tsx
+++ b/src/js/touchevents.tsx
@@ -2,6 +2,7 @@ import { addBreadcrumb, getCurrentHub } from '@sentry/core';
 import type { SeverityLevel } from '@sentry/types';
 import { logger } from '@sentry/utils';
 import * as React from 'react';
+import type { GestureResponderEvent} from 'react-native';
 import { StyleSheet, View } from 'react-native';
 
 import { createIntegration } from './integrations/factory';
@@ -62,6 +63,10 @@ interface ElementInstance {
   return?: ElementInstance;
 }
 
+interface PrivateGestureResponderEvent extends GestureResponderEvent {
+  _targetInst?: ElementInstance;
+}
+
 /**
  * Boundary to log breadcrumbs for interaction events.
  */
@@ -155,7 +160,7 @@ class TouchEventBoundary extends React.Component<TouchEventBoundaryProps> {
    * @param e
    */
   // eslint-disable-next-line complexity
-  private _onTouchStart(e: { _targetInst?: ElementInstance }): void {
+  private _onTouchStart(e: PrivateGestureResponderEvent): void {
     if (!e._targetInst) {
       return;
     }
diff --git a/src/js/tracing/gesturetracing.ts b/src/js/tracing/gesturetracing.ts
new file mode 100644
index 0000000000..2ae4391e77
--- /dev/null
+++ b/src/js/tracing/gesturetracing.ts
@@ -0,0 +1,149 @@
+import { getCurrentHub } from '@sentry/core';
+import type { Breadcrumb, Hub } from '@sentry/types';
+import { logger } from '@sentry/utils';
+
+import { UI_ACTION } from './ops';
+import { ReactNativeTracing } from './reactnativetracing';
+
+export const DEFAULT_BREADCRUMB_CATEGORY = 'gesture';
+export const DEFAULT_BREADCRUMB_TYPE = 'user';
+
+export const GESTURE_POSTFIX_LENGTH = 'GestureHandler'.length;
+export const ACTION_GESTURE_FALLBACK = 'gesture';
+
+/**
+ * Internal interface following RNGH 2 Gesture Event API.
+ * We need to use this to avoid importing RNGH 2 types and depending on it.
+ * https://github.com/software-mansion/react-native-gesture-handler/blob/f0868f7ccf678c947ef65519ebf97ae149a10289/src/handlers/gestures/gesture.ts#L55
+ * @hidden
+ */
+type GestureEvent = Record<string, unknown>;
+
+/**
+ * Internal interface for RNGH 2 Gesture API.
+ * We need to use this to avoid importing RNGH 2 types and depending on it.
+ * https://github.com/software-mansion/react-native-gesture-handler/blob/2.9.0/src/handlers/gestures/gesture.ts#L120
+ * @hidden
+ */
+interface BaseGesture {
+  handlers?: {
+    onBegin?: (event: GestureEvent) => void;
+    onEnd?: (event: GestureEvent) => void;
+  };
+  handlerName: string;
+}
+
+interface GestureTracingOptions {
+  getCurrentHub: () => Hub;
+}
+
+/**
+ * Patches React Native Gesture Handler v2 Gesture to start a transaction on gesture begin with the appropriate label.
+ * Example: ShoppingCartScreen.dismissGesture
+ */
+export function sentryTraceGesture<GestureT>(
+  /**
+   * Label of the gesture to be used in transaction name.
+   * Example: dismissGesture
+   */
+  label: string,
+  gesture: GestureT,
+  options: Partial<GestureTracingOptions> = {},
+): GestureT {
+  const gestureCandidate = gesture as unknown as BaseGesture | undefined | null;
+  if (!gestureCandidate) {
+    logger.warn('[GestureTracing] Gesture can not be undefined');
+    return gesture;
+  }
+  if (!gestureCandidate.handlers) {
+    logger.warn('[GestureTracing] Can not wrap gesture without handlers. If you want to wrap a gesture composition wrap individual gestures.');
+    return gesture;
+  }
+  if (!label) {
+    logger.warn('[GestureTracing] Can not wrap gesture without name.');
+    return gesture;
+  }
+  const hub = options.getCurrentHub?.() || getCurrentHub();
+
+  const name = gestureCandidate.handlerName.length > GESTURE_POSTFIX_LENGTH
+    ? gestureCandidate.handlerName
+      .substring(0, gestureCandidate.handlerName.length - GESTURE_POSTFIX_LENGTH).toLowerCase()
+    : ACTION_GESTURE_FALLBACK;
+
+  const originalOnBegin = gestureCandidate.handlers.onBegin;
+  (gesture as unknown as Required<BaseGesture>).handlers.onBegin = (event: GestureEvent) => {
+    hub.getClient()?.getIntegration(ReactNativeTracing)
+      ?.startUserInteractionTransaction({ elementId: label, op: `${UI_ACTION}.${name}` });
+
+    addGestureBreadcrumb(`Gesture ${label} begin.`, { event, hub, name });
+
+    if (originalOnBegin) {
+      originalOnBegin(event);
+    }
+  };
+
+  const originalOnEnd = gestureCandidate.handlers.onEnd;
+  (gesture as unknown as Required<BaseGesture>).handlers.onEnd = (event: GestureEvent) => {
+    addGestureBreadcrumb(`Gesture ${label} end.`, { event, hub, name });
+
+    if (originalOnEnd) {
+      originalOnEnd(event);
+    }
+  };
+
+  return gesture;
+}
+
+function addGestureBreadcrumb(
+  message: string,
+  options: {
+    event: Record<string, unknown> | undefined | null;
+    hub: Hub;
+    name: string;
+  },
+): void {
+  const { event, hub, name } = options;
+  const crumb: Breadcrumb = {
+    message,
+    level: 'info',
+    type: DEFAULT_BREADCRUMB_TYPE,
+    category: DEFAULT_BREADCRUMB_CATEGORY,
+  };
+
+  if (event) {
+    const data: Record<string, unknown> = {
+      gesture: name,
+    };
+    for (const key of Object.keys(GestureEventKeys)) {
+      const eventKey = GestureEventKeys[key as keyof typeof GestureEventKeys];
+      if (eventKey in event) {
+        data[eventKey] = event[eventKey];
+      }
+    }
+    crumb.data = data;
+  }
+
+  hub.addBreadcrumb(crumb);
+
+  logger.log(`[GestureTracing] ${crumb.message}`);
+}
+
+/**
+ * Selected keys from RNGH 2 Gesture Event API.
+ * We only want to send relevant data to save on payload size.
+ * @hidden
+ */
+const GestureEventKeys = {
+  NUMBER_OF_POINTERS: 'numberOfPointers',
+  NUMBER_OF_TOUCHES: 'numberOfTouches',
+  FORCE: 'force',
+  FORCE_CHANGE: 'forceChange',
+  ROTATION: 'rotation',
+  ROTATION_CHANGE: 'rotationChange',
+  SCALE: 'scale',
+  SCALE_CHANGE: 'scaleChange',
+  DURATION: 'duration',
+  VELOCITY: 'velocity',
+  VELOCITY_X: 'velocityX',
+  VELOCITY_Y: 'velocityY',
+} as const;
diff --git a/src/js/tracing/index.ts b/src/js/tracing/index.ts
index cd7f3ac366..a811d084e8 100644
--- a/src/js/tracing/index.ts
+++ b/src/js/tracing/index.ts
@@ -21,4 +21,8 @@ export {
 
 export { ReactNativeProfiler } from './reactnativeprofiler';
 
+export {
+  sentryTraceGesture,
+} from './gesturetracing';
+
 export * from './ops';
diff --git a/src/js/tracing/ops.ts b/src/js/tracing/ops.ts
index 6675190bd8..fa852bcfe8 100644
--- a/src/js/tracing/ops.ts
+++ b/src/js/tracing/ops.ts
@@ -3,6 +3,7 @@ export const DEFAULT = 'default';
 export const NAVIGATION = 'navigation';
 
 export const UI_LOAD = 'ui.load';
+export const UI_ACTION = 'ui.action';
 export const UI_ACTION_TOUCH = 'ui.action.touch';
 
 export const APP_START_COLD = 'app.start.cold';
diff --git a/test/tracing/gesturetracing.test.ts b/test/tracing/gesturetracing.test.ts
new file mode 100644
index 0000000000..bb74433dec
--- /dev/null
+++ b/test/tracing/gesturetracing.test.ts
@@ -0,0 +1,268 @@
+import { BrowserClient } from '@sentry/browser';
+import type { BrowserClientOptions } from '@sentry/browser/types/client';
+import { Hub } from '@sentry/core';
+import type { IntegrationIndex } from '@sentry/core/types/integration';
+import type { Breadcrumb, Scope, Transaction, User } from '@sentry/types';
+
+import { UI_ACTION } from '../../src/js/tracing';
+import {
+  DEFAULT_BREADCRUMB_CATEGORY as DEFAULT_GESTURE_BREADCRUMB_CATEGORY,
+  DEFAULT_BREADCRUMB_TYPE as DEFAULT_GESTURE_BREADCRUMB_TYPE,
+  sentryTraceGesture,
+} from '../../src/js/tracing/gesturetracing';
+import { ReactNativeTracing } from '../../src/js/tracing/reactnativetracing';
+import type {
+  MockedRoutingInstrumentation
+} from './mockedrountinginstrumention';
+import {
+  createMockedRoutingInstrumentation,
+  mockedConfirmedRouteTransactionContext
+} from './mockedrountinginstrumention';
+
+jest.mock('../../src/js/wrapper', () => {
+  return {
+    NATIVE: {
+      fetchNativeAppStart: jest.fn(),
+      fetchNativeFrames: jest.fn(() => Promise.resolve()),
+      enableNativeFramesTracking: jest.fn(() => Promise.resolve()),
+      enableNative: true,
+    },
+  };
+});
+
+const getMockScope = () => {
+  let scopeTransaction: unknown;
+  let scopeUser: User | undefined;
+
+  return {
+    getTransaction: () => scopeTransaction,
+    setSpan: jest.fn((span: unknown) => {
+      scopeTransaction = span;
+    }),
+    setTag(_tag: unknown) {
+      // Placeholder
+    },
+    addBreadcrumb(_breadcrumb: unknown) {
+      // Placeholder
+    },
+    getUser: () => scopeUser,
+  }
+};
+
+const mockAddBreadcrumb = jest.fn();
+
+const getMockHub = () => {
+  const mockHub = new Hub(new BrowserClient({ tracesSampleRate: 1 } as BrowserClientOptions));
+  const mockScope = getMockScope();
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mockHub.getScope = () => mockScope as any;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mockHub.configureScope = jest.fn((callback) => callback(mockScope as any));
+
+  mockHub.addBreadcrumb = mockAddBreadcrumb;
+
+  return mockHub;
+};
+
+interface MockGesture {
+  handlers?: {
+    onBegin?: jest.Mock;
+    onEnd?: jest.Mock;
+  };
+  handlerName: string;
+}
+
+describe('GestureTracing', () => {
+  const label = 'testGesture';
+
+  describe('gracefully fails on invalid gestures', () => {
+    it('gesture is undefined', () => {
+      const gesture = undefined;
+      expect(sentryTraceGesture(label, gesture)).toBeUndefined();
+    });
+
+    it('gesture has no handlers', () => {
+      const gesture = {};
+      expect(sentryTraceGesture(label, gesture)).toEqual({});
+    });
+  });
+
+  describe('traces gestures', () => {
+    let mockedScope: Scope;
+    let mockedHub: Hub;
+    let tracing: ReactNativeTracing;
+    let mockedRoutingInstrumentation: MockedRoutingInstrumentation;
+    let mockedGesture: MockGesture;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      jest.useFakeTimers();
+      mockedHub = getMockHub();
+      mockedScope = mockedHub.getScope()!;
+      mockedRoutingInstrumentation = createMockedRoutingInstrumentation();
+      tracing = new ReactNativeTracing({
+        routingInstrumentation: mockedRoutingInstrumentation,
+        enableUserInteractionTracing: true,
+      });
+      tracing.setupOnce(jest.fn(), jest.fn().mockReturnValue(mockedHub));
+      // client.addIntegration uses global getCurrentHub, so we don't use it to keep the mockedHub
+      (mockedHub.getClient() as unknown as { _integrations: IntegrationIndex })
+        ._integrations[ReactNativeTracing.name] = tracing;
+      mockedRoutingInstrumentation.registeredOnConfirmRoute!(mockedConfirmedRouteTransactionContext);
+      mockedGesture = {
+        handlers: {
+          onBegin: jest.fn(),
+          onEnd: jest.fn(),
+        },
+        handlerName: 'MockGestureHandler',
+      };
+    });
+
+    afterEach(() => {
+      jest.runAllTimers();
+      jest.useRealTimers();
+    });
+
+    it('gesture creates interaction transaction', () => {
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onBegin!();
+      const transaction = mockedScope.getTransaction() as Transaction | undefined;
+      jest.runAllTimers();
+
+      const transactionContext = transaction?.toContext();
+      expect(transactionContext).toEqual(expect.objectContaining({
+        endTimestamp: expect.any(Number),
+        op: `${UI_ACTION}.mock`,
+      }));
+    });
+
+    it('gesture interaction transaction falls back on invalid handler name', () => {
+      mockedGesture.handlerName = 'Invalid';
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onBegin!();
+      const transaction = mockedScope.getTransaction() as Transaction | undefined;
+      jest.runAllTimers();
+
+      const transactionContext = transaction?.toContext();
+      expect(transactionContext).toEqual(expect.objectContaining({
+        endTimestamp: expect.any(Number),
+        op: `${UI_ACTION}.gesture`,
+      }));
+    });
+
+    it('gesture cancel previous interaction transaction', () => {
+      const timeoutCloseToActualIdleTimeoutMs = 800;
+
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+
+      const mockedTouchInteractionId = { elementId: 'mockedElementId', op: 'mocked.op' };
+      tracing.startUserInteractionTransaction(mockedTouchInteractionId);
+      const touchTransaction = mockedScope.getTransaction() as Transaction | undefined;
+      touchTransaction?.startChild({ op: 'child.op' }).finish();
+      jest.advanceTimersByTime(timeoutCloseToActualIdleTimeoutMs);
+
+      mockedGesture.handlers?.onBegin?.();
+
+      const gestureTransaction = mockedScope.getTransaction() as Transaction | undefined;
+      jest.advanceTimersByTime(timeoutCloseToActualIdleTimeoutMs);
+      jest.runAllTimers();
+
+      const touchTransactionContext = touchTransaction?.toContext();
+      const gestureTransactionContext = gestureTransaction?.toContext();
+      expect(touchTransactionContext).toEqual(expect.objectContaining({
+        endTimestamp: expect.any(Number),
+        op: 'mocked.op',
+        sampled: true,
+      }));
+      expect(gestureTransactionContext).toEqual(expect.objectContaining({
+        endTimestamp: expect.any(Number),
+      }));
+    });
+
+    it('gesture original on begin handler is called', () => {
+      const original = mockedGesture.handlers?.onBegin;
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onBegin!();
+      jest.runAllTimers();
+
+      expect(original).toHaveBeenCalledTimes(1);
+    });
+
+    it('creates gesture on begin handled if non exists', () => {
+      delete mockedGesture.handlers?.onBegin;
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onBegin!();
+      jest.runAllTimers();
+
+      expect(mockedGesture.handlers?.onBegin).toBeDefined();
+    });
+
+    it('gesture original on end handler is called', () => {
+      const original = mockedGesture.handlers?.onEnd;
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onEnd!();
+      jest.runAllTimers();
+
+      expect(original).toHaveBeenCalledTimes(1);
+    });
+
+    it('creates gesture on end handled if non exists', () => {
+      delete mockedGesture.handlers?.onEnd;
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onEnd!();
+      jest.runAllTimers();
+
+      expect(mockedGesture.handlers?.onBegin).toBeDefined();
+    });
+
+    it('creates gesture on begin handled if non exists', () => {
+      delete mockedGesture.handlers?.onBegin;
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onBegin!();
+      jest.runAllTimers();
+
+      expect(mockedGesture.handlers?.onBegin).toBeDefined();
+    });
+
+    it('wrapped gesture creates breadcrumb on begin', () => {
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onBegin!();
+      jest.runAllTimers();
+
+      expect(mockAddBreadcrumb).toHaveBeenCalledTimes(1);
+      expect(mockAddBreadcrumb).toHaveBeenCalledWith(expect.objectContaining(<Breadcrumb>{
+        category: DEFAULT_GESTURE_BREADCRUMB_CATEGORY,
+        type: DEFAULT_GESTURE_BREADCRUMB_TYPE,
+        level: 'info',
+      }));
+    });
+
+    it('wrapped gesture creates breadcrumb on end', () => {
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onEnd!();
+      jest.runAllTimers();
+
+      expect(mockAddBreadcrumb).toHaveBeenCalledTimes(1);
+      expect(mockAddBreadcrumb).toHaveBeenCalledWith(expect.objectContaining(<Breadcrumb>{
+        category: DEFAULT_GESTURE_BREADCRUMB_CATEGORY,
+        type: DEFAULT_GESTURE_BREADCRUMB_TYPE,
+        level: 'info',
+      }));
+    });
+
+    it('wrapped gesture creates breadcrumb only with selected event keys', () => {
+      sentryTraceGesture('mockedGesture', mockedGesture, { getCurrentHub: () => mockedHub });
+      mockedGesture.handlers!.onBegin!({ notSelectedKey: 'notSelectedValue', scale: 1 });
+      jest.runAllTimers();
+
+      expect(mockAddBreadcrumb).toHaveBeenCalledTimes(1);
+      expect(mockAddBreadcrumb).toHaveBeenCalledWith(expect.objectContaining(<Breadcrumb>{
+        data: {
+          scale: 1,
+          gesture: 'mock',
+        },
+      }));
+    });
+  });
+});
diff --git a/test/tracing/mockedrountinginstrumention.ts b/test/tracing/mockedrountinginstrumention.ts
new file mode 100644
index 0000000000..25cd3e5dd6
--- /dev/null
+++ b/test/tracing/mockedrountinginstrumention.ts
@@ -0,0 +1,35 @@
+import type { RoutingInstrumentation } from '../../src/js';
+import type { OnConfirmRoute,TransactionCreator } from '../../src/js/tracing/routingInstrumentation';
+import type { BeforeNavigate } from '../../src/js/tracing/types';
+
+export interface MockedRoutingInstrumentation extends RoutingInstrumentation {
+  registeredListener?: TransactionCreator,
+  registeredBeforeNavigate?: BeforeNavigate,
+  registeredOnConfirmRoute?: OnConfirmRoute,
+}
+
+export const createMockedRoutingInstrumentation = (): MockedRoutingInstrumentation => {
+  const mock: MockedRoutingInstrumentation = {
+    name: 'TestRoutingInstrumentationInstance',
+    onRouteWillChange: jest.fn(),
+    registerRoutingInstrumentation: jest.fn((
+      listener: TransactionCreator,
+      beforeNavigate: BeforeNavigate,
+      onConfirmRoute: OnConfirmRoute,
+    ) => {
+      mock.registeredListener = listener;
+      mock.registeredBeforeNavigate = beforeNavigate;
+      mock.registeredOnConfirmRoute = onConfirmRoute;
+    }),
+  }
+  return mock;
+};
+
+export const mockedConfirmedRouteTransactionContext = {
+  name: 'mockedRouteName',
+  data: {
+    route: {
+      name: 'mockedRouteName',
+    },
+  },
+};
diff --git a/test/tracing/reactnativetracing.test.ts b/test/tracing/reactnativetracing.test.ts
index a918b75bae..b950fa52a5 100644
--- a/test/tracing/reactnativetracing.test.ts
+++ b/test/tracing/reactnativetracing.test.ts
@@ -6,9 +6,7 @@ import type { IdleTransaction, SpanStatusType } from '@sentry/tracing';
 import { Transaction } from '@sentry/tracing';
 
 import type { NativeAppStartResponse } from '../../src/js/NativeRNSentry';
-import type { OnConfirmRoute, TransactionCreator } from '../../src/js/tracing/routingInstrumentation';
 import { RoutingInstrumentation } from '../../src/js/tracing/routingInstrumentation';
-import type { BeforeNavigate } from '../../src/js/tracing/types';
 
 jest.mock('../../src/js/wrapper', () => {
   return {
@@ -76,6 +74,8 @@ import { ReactNativeTracing } from '../../src/js/tracing/reactnativetracing';
 import { getTimeOriginMilliseconds } from '../../src/js/tracing/utils';
 import { NATIVE } from '../../src/js/wrapper';
 import { firstArg, mockFunction } from '../testutils';
+import type { MockedRoutingInstrumentation } from './mockedrountinginstrumention';
+import { createMockedRoutingInstrumentation, mockedConfirmedRouteTransactionContext } from './mockedrountinginstrumention';
 
 const DEFAULT_IDLE_TIMEOUT = 1000;
 
@@ -672,41 +672,17 @@ describe('ReactNativeTracing', () => {
   });
 
   describe('User Interaction Tracing', () => {
-    const mockedConfirmedRouteTransactionContext = {
-      name: 'mockedRouteName',
-      data: {
-        route: {
-          name: 'mockedRouteName',
-        },
-      },
-    };
     let mockedScope: Scope;
     let mockedHub: Hub;
     let tracing: ReactNativeTracing;
     let mockedUserInteractionId: { elementId: string | undefined; op: string; };
-    let mockedRoutingInstrumentation: RoutingInstrumentation & {
-      registeredListener?: TransactionCreator,
-      registeredBeforeNavigate?: BeforeNavigate,
-      registeredOnConfirmRoute?: OnConfirmRoute,
-    };
+    let mockedRoutingInstrumentation: MockedRoutingInstrumentation;
 
     beforeEach(() => {
       mockedUserInteractionId = { elementId: 'mockedElementId', op: 'mocked.op' };
       mockedHub = getMockHub();
       mockedScope = mockedHub.getScope()!;
-      mockedRoutingInstrumentation = {
-        name: 'TestRoutingInstrumentationInstance',
-        onRouteWillChange: jest.fn(),
-        registerRoutingInstrumentation: jest.fn((
-          listener: TransactionCreator,
-          beforeNavigate: BeforeNavigate,
-          onConfirmRoute: OnConfirmRoute,
-        ) => {
-          mockedRoutingInstrumentation.registeredListener = listener;
-          mockedRoutingInstrumentation.registeredBeforeNavigate = beforeNavigate;
-          mockedRoutingInstrumentation.registeredOnConfirmRoute = onConfirmRoute;
-        }),
-      };
+      mockedRoutingInstrumentation = createMockedRoutingInstrumentation();
     });
 
     describe('disabled user interaction', () => {