refactor: Send signature metrics as event fragments in middleware & f…

…eat: Add signature alert metrics to events (#26597)

<!--
Please submit this PR as a draft initially.
Do not mark it as "Ready for review" until the template has been
completely filled out, and PR status checks have passed at least once.
-->

## **Description**

- If the RPC request is a signature, send the event using event
fragments so that we can add additional props before sending the final
event
  - Pass MetaMetricsController to createRPCMethodTrackingMiddleware
- Add signature alert metrics to events

[![Open in GitHub
Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/MetaMask/metamask-extension/pull/26597?quickstart=1)

## **Related issues**

Fixes: MetaMask/MetaMask-planning#2718
Blocked by: https://github.com/MetaMask/core/pull/4636/files and
following PRs to update packages

## **Manual testing steps**

1. Turn on metametrics through MM settings
2. Go to test-dapp
3. Trigger signature with alerts (e.g. Sign-in with Ethereum (Bad
Domain))
4. Observe new alert metrics in Segment/Mixpanel Signature
Rejected/Approved events

## **Screenshots/Recordings**

<!-- If applicable, add screenshots and/or recordings to visualize the
before and after of your change. -->

### **Before**

<!-- [screenshots/recordings] -->

### **After**

<!-- [screenshots/recordings] -->

## **Pre-merge author checklist**

- [ ] I've followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask
Extension Coding
Standards](https://github.com/MetaMask/metamask-extension/blob/develop/.github/guidelines/CODING_GUIDELINES.md).
- [ ] I've completed the PR template to the best of my ability
- [ ] I’ve included tests if applicable
- [ ] I’ve documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [ ] I’ve applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-extension/blob/develop/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.

app/scripts/lib/createRPCMethodTrackingMiddleware.js

@@ -18,7 +18,10 @@ import {
   PRIMARY_TYPES_PERMIT,
 } from '../../../shared/constants/signatures';
 import { SIGNING_METHODS } from '../../../shared/constants/transaction';
-import { getBlockaidMetricsProps } from '../../../ui/helpers/utils/metrics';
+import {
+  generateSignatureUniqueId,
+  getBlockaidMetricsProps,
+} from '../../../ui/helpers/utils/metrics';
 import { REDESIGN_APPROVAL_TYPES } from '../../../ui/pages/confirmations/utils/confirm';
 import { getSnapAndHardwareInfoForMetrics } from './snap-keyring/metrics';
 
@@ -123,14 +126,58 @@ const TRANSFORM_PARAMS_MAP = {
 const rateLimitTimeoutsByMethod = {};
 let globalRateLimitCount = 0;
 
+/**
+ * Create signature request event fragment with an assigned unique identifier
+ *
+ * @param {MetaMetricsController} metaMetricsController
+ * @param {OriginalRequest} req
+ * @param {object} properties
+ */
+function createSignatureFragment(metaMetricsController, req, properties) {
+  metaMetricsController.createEventFragment({
+    category: MetaMetricsEventCategory.InpageProvider,
+    initialEvent: MetaMetricsEventName.SignatureRequested,
+    successEvent: MetaMetricsEventName.SignatureApproved,
+    failureEvent: MetaMetricsEventName.SignatureRejected,
+    uniqueIdentifier: generateSignatureUniqueId(req.id),
+    persist: true,
+    referrer: {
+      url: req.origin,
+    },
+    properties,
+  });
+}
+
+/**
+ * Updates and finalizes event fragment for signature requests
+ *
+ * @param {MetaMetricsController} metaMetricsController
+ * @param {OriginalRequest} req
+ * @param {object}  options
+ * @param {boolean} options.abandoned
+ * @param {object}  options.properties
+ */
+function finalizeSignatureFragment(
+  metaMetricsController,
+  req,
+  { abandoned, properties },
+) {
+  const signatureUniqueId = generateSignatureUniqueId(req.id);
+
+  metaMetricsController.updateEventFragment(signatureUniqueId, {
+    properties,
+  });
+  metaMetricsController.finalizeEventFragment(signatureUniqueId, {
+    abandoned,
+  });
+}
+
 /**
  * Returns a middleware that tracks inpage_provider usage using sampling for
  * each type of event except those that require user interaction, such as
  * signature requests
  *
  * @param {object} opts - options for the rpc method tracking middleware
- * @param {Function} opts.trackEvent - trackEvent method from
- *  MetaMetricsController
  * @param {Function} opts.getMetricsState - get the state of
  *  MetaMetricsController
  * @param {number} [opts.rateLimitTimeout] - time, in milliseconds, to wait before
@@ -145,11 +192,12 @@ let globalRateLimitCount = 0;
  * time window that should limit the number of method calls tracked to globalRateLimitMaxAmount.
  * @param {number} [opts.globalRateLimitMaxAmount] - max number of method calls that should
  * tracked within the globalRateLimitTimeout time window.
+ * @param {AppStateController} [opts.appStateController]
+ * @param {MetaMetricsController} [opts.metaMetricsController]
  * @returns {Function}
  */
 
 export default function createRPCMethodTrackingMiddleware({
-  trackEvent,
   getMetricsState,
   rateLimitTimeout = 60 * 5 * 1000, // 5 minutes
   rateLimitSamplePercent = 0.001, // 0.1%
@@ -160,6 +208,7 @@ export default function createRPCMethodTrackingMiddleware({
   isConfirmationRedesignEnabled,
   snapAndHardwareMessenger,
   appStateController,
+  metaMetricsController,
 }) {
   return async function rpcMethodTrackingMiddleware(
     /** @type {any} */ req,
@@ -216,6 +265,8 @@ export default function createRPCMethodTrackingMiddleware({
       // Don't track if the user isn't participating in metametrics
       userParticipatingInMetaMetrics === true;
 
+    let signatureUniqueId;
+
     if (shouldTrackEvent) {
       // We track an initial "requested" event as soon as the dapp calls the
       // provider method. For the events not special cased this is the only
@@ -316,14 +367,18 @@ export default function createRPCMethodTrackingMiddleware({
         eventProperties.params = transformParams(params);
       }
 
-      trackEvent({
-        event,
-        category: MetaMetricsEventCategory.InpageProvider,
-        referrer: {
-          url: origin,
-        },
-        properties: eventProperties,
-      });
+      if (event === MetaMetricsEventName.SignatureRequested) {
+        createSignatureFragment(metaMetricsController, req, eventProperties);
+      } else {
+        metaMetricsController.trackEvent({
+          event,
+          category: MetaMetricsEventCategory.InpageProvider,
+          referrer: {
+            url: origin,
+          },
+          properties: eventProperties,
+        });
+      }
 
       if (rateLimitType === RATE_LIMIT_TYPES.TIMEOUT) {
         rateLimitTimeoutsByMethod[method] = setTimeout(() => {
@@ -372,22 +427,23 @@ export default function createRPCMethodTrackingMiddleware({
         ...eventProperties,
         ...blockaidMetricProps,
         location,
-        // if security_alert_response from blockaidMetricProps is Benign, force set security_alert_reason to empty string
-        security_alert_reason:
-          blockaidMetricProps.security_alert_response ===
-          BlockaidResultType.Benign
-            ? ''
-            : blockaidMetricProps.security_alert_reason,
       };
 
-      trackEvent({
-        event,
-        category: MetaMetricsEventCategory.InpageProvider,
-        referrer: {
-          url: origin,
-        },
-        properties,
-      });
+      if (signatureUniqueId) {
+        finalizeSignatureFragment(metaMetricsController, req, {
+          abandoned: event === eventType.REJECTED,
+          properties,
+        });
+      } else {
+        metaMetricsController.trackEvent({
+          event,
+          category: MetaMetricsEventCategory.InpageProvider,
+          referrer: {
+            url: origin,
+          },
+          properties,
+        });
+      }
 
       return callback();
     });