@deeeed/metamask-harness 0.44.3 → 0.45.1

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## Unreleased
 
+## 0.45.1 - 2026-09-01
+
+### Fixed
+
+- Stop Mobile Perps order actions from forcing a connection reset after submission; completion now relies on observed position or open-order state.
+- Preserve the first recipe failure on every adapter instead of reloading or retrying the product runtime behind the proof.
+- Keep Extension TP/SL updates on the current page and require persistence reloads to be explicit recipe lifecycle steps.
+- Document and enforce the rule that ordinary proof actions cannot hide lifecycle recovery, cache clearing, state resets, or journey retries.
+
+## 0.45.0 - 2026-08-28
+
+### Changed
+
+- Read Android UI frames from host-side `gfxinfo framestats`, keep iOS on React Native CDP frame events, and emit bounded Chrome Trace Event artifacts beside the JSON and HTML reports.
+- Report refresh-rate-aware active FPS only while frames are produced, cap it at the detected display rate, mark sparse windows `N/A`, and describe Mobile JavaScript tasks as not applicable.
+- Publish the breaking UI smoothness summary schema v2 for the active-FPS field set, report unclassified iOS cadence gaps as partial with FPS unavailable, classify Android deadline misses from `FrameDeadline`, and bound retained CDP trace data to 16 MiB.
+- Keep Mobile trace counts host-wide because React Native native frame events can use a different process from the Hermes clock marker; scope Extension events to its proven renderer process.
+- Put recipe-node intervals on the raw Chrome trace host clock and keep Android deadline or refresh-budget classifications consistent with the summary.
+
+### Fixed
+
+- Follow the ready Hermes generation for a pinned device after target rotation and wait for unlock state to settle without restarting Metro, the app, or the simulator.
+- Preserve visible iOS testID nodes with generic accessibility roles, make Perps Lite/Pro navigation persistent and stale-snapshot-safe on both platforms, retry native state assertions until their deadline, and fall back to Agent Device when Android returns an empty UIAutomator hierarchy.
+
 ## 0.44.3 - 2026-08-28
 
 ### Fixed

package/adapters/mobile/bridge-runtime/lib/cdp-broker.cjs

@@ -414,7 +414,10 @@ function createCdpBroker({
 
   function settleTargetWaiters() {
     for (const waiter of [...targetWaiters]) {
-      const targets = targetList({ nameIncludes: waiter.nameIncludes });
+      const targets = targetList({
+        nameIncludes: waiter.nameIncludes,
+        readyOnly: true,
+      });
       if (targets.length === 0) continue;
       targetWaiters.delete(waiter);
       clearTimeout(waiter.timer);
@@ -423,7 +426,10 @@ function createCdpBroker({
   }
 
   function resolveTargets(params, timeoutMs, socket) {
-    const existing = targetList({ nameIncludes: params.nameIncludes });
+    const existing = targetList({
+      nameIncludes: params.nameIncludes,
+      readyOnly: true,
+    });
     if (existing.length > 0) return Promise.resolve(existing);
     requestDiscovery?.('');
     return new Promise((resolve, reject) => {
@@ -807,6 +813,18 @@ function createCdpBroker({
       const session = sessions.get(deviceId);
       if (!session?.brokerReady) return;
       const previous = knownTargets.get(deviceId);
+      const name = String(session.name || previous?.name || '');
+      for (const [otherDeviceId, target] of knownTargets) {
+        if (
+          otherDeviceId !== deviceId &&
+          name &&
+          target.name === name &&
+          target.ready &&
+          !sessions.get(otherDeviceId)?.brokerReady
+        ) {
+          knownTargets.set(otherDeviceId, { ...target, ready: false });
+        }
+      }
       const sessionChanged = observedSessions.get(deviceId) !== session;
       knownTargets.set(deviceId, {
         deviceId,
@@ -814,7 +832,7 @@ function createCdpBroker({
           previous?.generation === undefined
             ? 1
             : previous.generation + (!previous.ready || sessionChanged ? 1 : 0),
-        name: String(session.name || previous?.name || ''),
+        name,
         ready: true,
       });
       observedSessions.set(deviceId, session);

package/dist/adapters/mobile/android-gfxinfo-performance.js

@@ -0,0 +1,368 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import {
+  summarizeFrames
+} from "./frame-metrics.js";
+const execFileAsync = promisify(execFile);
+const POLL_INTERVAL_MS = 750;
+const MAX_FRAMES = 1e5;
+const GFXINFO_FRAME_BUFFER_SIZE = 120;
+const GFXINFO_SAFE_NEW_FRAME_LIMIT = Math.floor(
+  GFXINFO_FRAME_BUFFER_SIZE * 0.9
+);
+function createAndroidGfxinfoPerformanceBackend(env) {
+  const serial = String(
+    env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? env.ANDROID_DEVICE ?? ""
+  ).trim();
+  if (!serial) {
+    throw new Error(
+      "Android performance capture requires ADB_SERIAL, ANDROID_SERIAL, or a serial-valued ANDROID_DEVICE from --device."
+    );
+  }
+  const packageId = String(env.ANDROID_PACKAGE_ID ?? "io.metamask").trim();
+  const adb = String(env.ADB_PATH ?? "adb");
+  let active;
+  return {
+    async start(id) {
+      if (active) {
+        throw new Error("Only one Android performance trace may be active.");
+      }
+      const clock = await synchronizeAndroidClock(adb, serial, packageId);
+      await adbCommand(adb, serial, [
+        "shell",
+        "dumpsys",
+        "gfxinfo",
+        packageId,
+        "reset"
+      ]);
+      const capture = {
+        clock,
+        coverageGapReasons: [],
+        frames: /* @__PURE__ */ new Map(),
+        id,
+        poll: Promise.resolve(),
+        polling: false
+      };
+      active = capture;
+      capture.timer = setInterval(() => queuePoll(capture), POLL_INTERVAL_MS);
+    },
+    async end(id) {
+      const capture = active;
+      if (!capture || capture.id !== id) {
+        throw new Error(`Performance capture is not active: ${id}`);
+      }
+      if (capture.timer) clearInterval(capture.timer);
+      await capture.poll;
+      await queuePoll(capture);
+      active = void 0;
+      return captureResult(capture);
+    },
+    async close() {
+      const capture = active;
+      if (!capture) return;
+      if (capture.timer) clearInterval(capture.timer);
+      await capture.poll;
+      await queuePoll(capture);
+      active = void 0;
+    }
+  };
+  function queuePoll(capture) {
+    if (capture.polling) return capture.poll;
+    capture.polling = true;
+    capture.poll = (async () => {
+      try {
+        const output = await adbCommand(adb, serial, [
+          "shell",
+          "dumpsys",
+          "gfxinfo",
+          packageId,
+          "framestats"
+        ]);
+        const parsed = parseFrameStats(output);
+        let newFrameCount = 0;
+        for (const frame of parsed.frames) {
+          if (capture.frames.size >= MAX_FRAMES) {
+            addGap(capture, "Android frame retention limit was reached.");
+            break;
+          }
+          const key = `${frame.vsyncId}:${frame.vsyncNs}`;
+          if (!capture.frames.has(key)) newFrameCount += 1;
+          capture.frames.set(key, frame);
+        }
+        if (parsed.bufferCapacityReached && newFrameCount >= GFXINFO_SAFE_NEW_FRAME_LIMIT) {
+          addGap(
+            capture,
+            "Android gfxinfo may have overwritten frames between polls."
+          );
+        }
+      } catch (error) {
+        addGap(
+          capture,
+          `Android gfxinfo poll failed: ${errorMessage(error).slice(0, 180)}`
+        );
+      }
+    })().finally(() => {
+      capture.polling = false;
+    });
+    return capture.poll;
+  }
+}
+function captureResult(capture) {
+  const rows = [...capture.frames.values()].sort(
+    (first, second) => first.intendedVsyncNs - second.intendedVsyncNs
+  );
+  const fallbackBudgetMs = estimateFrameBudgetMs(rows);
+  const samples = rows.map((row) => {
+    const measurement = frameMeasurement(row, fallbackBudgetMs);
+    const startedAtEpochMs = capture.clock.hostEpochAtDeviceUptimeMs + row.intendedVsyncNs / 1e6;
+    return {
+      completedAtEpochMs: startedAtEpochMs + measurement.durationMs,
+      durationMs: measurement.durationMs,
+      ...measurement.frameBudgetMs ? {
+        frameBudgetMs: measurement.frameBudgetMs
+      } : {},
+      ...measurement.overBudget === void 0 ? {} : { overBudget: measurement.overBudget },
+      startedAtEpochMs
+    };
+  });
+  const noFrames = samples.length === 0;
+  const status = noFrames ? "unavailable" : capture.coverageGapReasons.length > 0 ? "partial" : "complete";
+  const unavailableReasons = noFrames ? ["No Android gfxinfo frame samples were recorded."] : [];
+  const coverageGapReasons = [...capture.coverageGapReasons];
+  const rawTraceEvents = buildAndroidFrameTraceEvents(
+    rows,
+    capture.clock,
+    fallbackBudgetMs
+  );
+  return {
+    platform: "android",
+    javascript: notApplicableJavaScript(),
+    nativeUi: {
+      status,
+      kind: "android-gfxinfo-framestats",
+      unavailableReasons,
+      coverageGapReasons,
+      samples,
+      summary: summarizeFrames(samples),
+      clockSyncUncertaintyMs: capture.clock.uncertaintyMs
+    },
+    trace: {
+      beginFrameCount: rows.length,
+      dataLossOccurred: coverageGapReasons.length > 0,
+      drawFrameCount: rows.length,
+      overflow: capture.frames.size >= MAX_FRAMES,
+      profileChunkCount: 0,
+      runTaskCount: 0,
+      scope: "mobile-host",
+      totalEventCount: rawTraceEvents.length
+    },
+    rawTraceEvents
+  };
+}
+function parseFrameStats(output) {
+  const frames = [];
+  let bufferCapacityReached = false;
+  let columnsByName;
+  let sectionRowCount = 0;
+  let sawHeader = false;
+  for (const line of output.split(/\r?\n/u)) {
+    if (line === "---PROFILEDATA---") {
+      bufferCapacityReached ||= sectionRowCount >= GFXINFO_FRAME_BUFFER_SIZE;
+      columnsByName = void 0;
+      sectionRowCount = 0;
+      continue;
+    }
+    if (line.startsWith("Flags,")) {
+      columnsByName = new Map(
+        line.split(",").map((name, index) => [name.trim(), index])
+      );
+      sawHeader = true;
+      const missing = ["Flags", "IntendedVsync", "Vsync", "FrameCompleted"].filter((name) => !columnsByName?.has(name));
+      if (missing.length > 0) {
+        throw new Error(
+          `Unsupported Android gfxinfo framestats header; missing ${missing.join(", ")}.`
+        );
+      }
+      continue;
+    }
+    if (!/^\d+,/u.test(line)) continue;
+    if (!columnsByName) continue;
+    const columns = line.split(",");
+    sectionRowCount += 1;
+    if (Number(column(columns, columnsByName, "Flags")) !== 0) continue;
+    const intendedVsyncNs = Number(
+      column(columns, columnsByName, "IntendedVsync")
+    );
+    const vsyncNs = Number(column(columns, columnsByName, "Vsync"));
+    const deadlineNs = Number(
+      column(columns, columnsByName, "FrameDeadline") ?? 0
+    );
+    const frameIntervalNs = Number(
+      column(columns, columnsByName, "FrameInterval") ?? 0
+    );
+    const completedNs = Number(
+      column(columns, columnsByName, "FrameCompleted")
+    );
+    if (!positiveFinite(intendedVsyncNs) || !positiveFinite(vsyncNs) || !positiveFinite(completedNs) || completedNs <= intendedVsyncNs) {
+      continue;
+    }
+    frames.push({
+      completedNs,
+      deadlineNs,
+      frameIntervalNs,
+      intendedVsyncNs,
+      vsyncId: String(
+        column(columns, columnsByName, "FrameTimelineVsyncId") ?? intendedVsyncNs
+      ),
+      vsyncNs
+    });
+  }
+  bufferCapacityReached ||= sectionRowCount >= GFXINFO_FRAME_BUFFER_SIZE;
+  if (output.includes("---PROFILEDATA---") && !sawHeader) {
+    throw new Error("Android gfxinfo framestats header was not found.");
+  }
+  return { bufferCapacityReached, frames };
+}
+function column(columns, columnsByName, name) {
+  const index = columnsByName.get(name);
+  return index === void 0 ? void 0 : columns[index];
+}
+function buildAndroidFrameTraceEvents(rows, clock, fallbackBudgetMs) {
+  return rows.flatMap((row, index) => {
+    const measurement = frameMeasurement(row, fallbackBudgetMs);
+    const args = {
+      frameSeqId: row.vsyncId || String(index),
+      durationMs: measurement.durationMs,
+      ...measurement.frameBudgetMs ? { frameBudgetMs: measurement.frameBudgetMs } : {},
+      ...measurement.overBudget === void 0 ? {} : {
+        overBudget: measurement.overBudget,
+        overBudgetClassification: measurement.classification
+      },
+      ...measurement.classification === "frame-deadline" ? { frameDeadlineMissed: measurement.overBudget } : {},
+      source: "android-gfxinfo"
+    };
+    const intendedVsyncEpochUs = (clock.hostEpochAtDeviceUptimeMs + row.intendedVsyncNs / 1e6) * 1e3;
+    const completedEpochUs = (clock.hostEpochAtDeviceUptimeMs + row.completedNs / 1e6) * 1e3;
+    return [
+      {
+        name: "BeginFrame",
+        cat: "disabled-by-default-devtools.timeline.frame",
+        ph: "I",
+        ts: intendedVsyncEpochUs,
+        pid: 1,
+        tid: 1,
+        args
+      },
+      {
+        name: "DrawFrame",
+        cat: "disabled-by-default-devtools.timeline.frame",
+        ph: "I",
+        ts: completedEpochUs,
+        pid: 1,
+        tid: 1,
+        args
+      }
+    ];
+  });
+}
+function frameMeasurement(row, fallbackBudgetMs) {
+  const durationMs = (row.completedNs - row.intendedVsyncNs) / 1e6;
+  const frameBudgetMs = row.frameIntervalNs > 0 ? row.frameIntervalNs / 1e6 : fallbackBudgetMs;
+  if (row.deadlineNs > row.intendedVsyncNs) {
+    return {
+      classification: "frame-deadline",
+      durationMs,
+      ...frameBudgetMs ? { frameBudgetMs } : {},
+      overBudget: row.completedNs > row.deadlineNs
+    };
+  }
+  return {
+    ...frameBudgetMs ? {
+      classification: "refresh-budget",
+      frameBudgetMs,
+      overBudget: durationMs > frameBudgetMs * 1.01
+    } : {},
+    durationMs
+  };
+}
+async function synchronizeAndroidClock(adb, serial, packageId) {
+  const before = Date.now();
+  const output = await adbCommand(adb, serial, [
+    "shell",
+    "dumpsys",
+    "gfxinfo",
+    packageId,
+    "framestats"
+  ]);
+  const after = Date.now();
+  const deviceUptimeMs = Number(/Uptime:\s+(\d+)/u.exec(output)?.[1]);
+  return androidClockSync(before, after, deviceUptimeMs);
+}
+function androidClockSync(beforeEpochMs, afterEpochMs, deviceUptimeMs) {
+  if (!positiveFinite(deviceUptimeMs)) {
+    throw new Error("Android performance capture could not read device uptime.");
+  }
+  return {
+    hostEpochAtDeviceUptimeMs: (beforeEpochMs + afterEpochMs) / 2 - deviceUptimeMs,
+    uncertaintyMs: (afterEpochMs - beforeEpochMs) / 2
+  };
+}
+async function adbCommand(adb, serial, args) {
+  const { stdout } = await execFileAsync(adb, ["-s", serial, ...args], {
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 1e4
+  });
+  return stdout;
+}
+function estimateFrameBudgetMs(rows) {
+  const intervals = [];
+  for (let index = 1; index < rows.length; index += 1) {
+    const previous = rows[index - 1];
+    const current = rows[index];
+    if (!previous || !current) continue;
+    const intervalMs = (current.intendedVsyncNs - previous.intendedVsyncNs) / 1e6;
+    if (intervalMs >= 3.5 && intervalMs <= 40) intervals.push(intervalMs);
+  }
+  if (intervals.length < 5) return void 0;
+  intervals.sort((first, second) => first - second);
+  const observed = percentile(intervals, 0.1);
+  const refreshRateHz = Math.round(1e3 / observed);
+  return refreshRateHz >= 24 && refreshRateHz <= 240 ? 1e3 / refreshRateHz : void 0;
+}
+function percentile(sorted, quantile) {
+  const position = (sorted.length - 1) * quantile;
+  const lower = Math.floor(position);
+  const upper = Math.ceil(position);
+  const lowerValue = sorted[lower] ?? 0;
+  const upperValue = sorted[upper] ?? lowerValue;
+  return lowerValue + (upperValue - lowerValue) * (position - lower);
+}
+function notApplicableJavaScript() {
+  return {
+    applicability: "not_applicable",
+    status: "unavailable",
+    kind: "not-applicable-mobile-js-tasks",
+    unavailableReasons: [],
+    coverageGapReasons: [],
+    samples: [],
+    summary: {}
+  };
+}
+function addGap(capture, reason) {
+  if (!capture.coverageGapReasons.includes(reason)) {
+    capture.coverageGapReasons.push(reason);
+  }
+}
+function positiveFinite(value) {
+  return Number.isFinite(value) && value > 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  androidClockSync,
+  buildAndroidFrameTraceEvents,
+  createAndroidGfxinfoPerformanceBackend,
+  parseFrameStats
+};

package/dist/adapters/mobile/frame-metrics.js

@@ -1,25 +1,69 @@
+const MIN_ACTIVE_INTERVALS = 5;
 function summarizeFrames(samples) {
-  const validSamples = samples.filter(
+  const allValidSamples = samples.filter(
     (sample) => Number.isFinite(sample.durationMs) && sample.durationMs > 0
   );
-  const durations = validSamples.map((sample) => sample.durationMs).sort((first2, second) => first2 - second);
-  if (durations.length === 0) return { frameCount: 0 };
-  const jankValues = validSamples.map((sample) => sample.janky).filter((value) => value !== void 0);
-  const jankyFrameCount = jankValues.filter(Boolean).length;
-  const first = validSamples[0]?.completedAtEpochMs;
-  const last = validSamples.at(-1)?.completedAtEpochMs;
-  const elapsedMs = first !== void 0 && last !== void 0 && last > first ? last - first : void 0;
+  const frameBudgetMs = commonFrameBudget(allValidSamples);
+  const cadenceSamples = allValidSamples.length > 0 && allValidSamples.every((sample) => sample.cadenceInterval === true);
+  const cadenceGaps = cadenceSamples && frameBudgetMs ? allValidSamples.filter(
+    (sample) => sample.durationMs > frameBudgetMs * 3.01
+  ) : [];
+  const validSamples = cadenceGaps.length > 0 ? allValidSamples.filter(
+    (sample) => sample.durationMs <= (frameBudgetMs ?? 0) * 3.01
+  ) : allValidSamples;
+  const durations = validSamples.map((sample) => sample.durationMs).sort((first, second) => first - second);
+  if (durations.length === 0) {
+    return {
+      fpsUnavailableReason: frameBudgetMs ? "insufficient_active_frames" : "refresh_rate_unavailable",
+      ...cadenceGaps.length > 0 ? {
+        cadenceGapCount: cadenceGaps.length,
+        longestCadenceGapMs: round(
+          Math.max(...cadenceGaps.map((sample) => sample.durationMs))
+        )
+      } : {},
+      ...frameBudgetMs ? {
+        frameBudgetMs: round(frameBudgetMs),
+        refreshRateHz: round(1e3 / frameBudgetMs)
+      } : {},
+      frameCount: 0
+    };
+  }
+  const frameBudgetOutcomes = validSamples.map((sample) => sample.overBudget).filter((value) => value !== void 0);
+  const missedFrameBudgetCount = frameBudgetOutcomes.filter(Boolean).length;
+  const activeIntervals = frameBudgetMs ? activeRenderingIntervals(validSamples, frameBudgetMs) : [];
+  const activeElapsedMs = activeIntervals.reduce(
+    (total, interval) => total + interval,
+    0
+  );
+  const hasActiveFps = cadenceGaps.length === 0 && activeIntervals.length >= MIN_ACTIVE_INTERVALS && activeElapsedMs > 0;
+  const refreshRateHz = frameBudgetMs ? 1e3 / frameBudgetMs : void 0;
   return {
-    ...elapsedMs ? {
-      averageFps: round(
-        (validSamples.length - 1) * 1e3 / elapsedMs
+    ...hasActiveFps ? {
+      activeFps: round(
+        Math.min(
+          refreshRateHz ?? Number.POSITIVE_INFINITY,
+          activeIntervals.length * 1e3 / activeElapsedMs
+        )
+      ),
+      fpsIntervalCount: activeIntervals.length
+    } : {
+      fpsUnavailableReason: frameBudgetMs ? cadenceGaps.length > 0 ? "unclassified_cadence_gap" : "insufficient_active_frames" : "refresh_rate_unavailable"
+    },
+    ...cadenceGaps.length > 0 ? {
+      cadenceGapCount: cadenceGaps.length,
+      longestCadenceGapMs: round(
+        Math.max(...cadenceGaps.map((sample) => sample.durationMs))
       )
     } : {},
+    ...frameBudgetMs ? {
+      frameBudgetMs: round(frameBudgetMs),
+      refreshRateHz: round(1e3 / frameBudgetMs)
+    } : {},
     frameCount: durations.length,
-    ...jankValues.length === validSamples.length ? {
-      jankyFrameCount,
-      jankyFramePercent: round(
-        jankyFrameCount / validSamples.length * 100
+    ...frameBudgetOutcomes.length === validSamples.length ? {
+      overBudgetFrameCount: missedFrameBudgetCount,
+      overBudgetFramePercent: round(
+        missedFrameBudgetCount / validSamples.length * 100
       )
     } : {},
     longestFrameMs: round(durations.at(-1) ?? 0),
@@ -28,6 +72,35 @@ function summarizeFrames(samples) {
     p99FrameMs: round(percentile(durations, 0.99))
   };
 }
+function commonFrameBudget(samples) {
+  const budgets = samples.map((sample) => sample.frameBudgetMs).filter(
+    (value) => value !== void 0 && Number.isFinite(value) && value > 0
+  ).sort((first, second) => first - second);
+  return budgets.length > 0 ? percentile(budgets, 0.5) : void 0;
+}
+function activeRenderingIntervals(samples, frameBudgetMs) {
+  if (samples.every((sample) => sample.cadenceInterval === true)) {
+    return samples.map((sample) => sample.durationMs).filter(
+      (durationMs) => Number.isFinite(durationMs) && durationMs > 0 && durationMs <= frameBudgetMs * 3.01
+    );
+  }
+  const ordered = [...samples].map((sample) => ({
+    ...sample,
+    startedAtEpochMs: sample.startedAtEpochMs ?? sample.completedAtEpochMs - sample.durationMs
+  })).sort((first, second) => first.startedAtEpochMs - second.startedAtEpochMs);
+  const intervals = [];
+  for (let index = 1; index < ordered.length; index += 1) {
+    const previous = ordered[index - 1];
+    const current = ordered[index];
+    if (!previous || !current) continue;
+    const interval = current.startedAtEpochMs - previous.startedAtEpochMs;
+    if (!Number.isFinite(interval) || interval <= 0) continue;
+    const continuous = interval <= frameBudgetMs * 3.01;
+    const explainedBySlowFrame = Math.max(previous.durationMs, current.durationMs) >= interval - frameBudgetMs * 1.01;
+    if (continuous || explainedBySlowFrame) intervals.push(interval);
+  }
+  return intervals;
+}
 function percentile(sorted, quantile) {
   if (sorted.length === 1) return sorted[0] ?? 0;
   const position = (sorted.length - 1) * quantile;

package/dist/adapters/mobile/performance-observer.js

@@ -4,7 +4,11 @@ import {
 import {
   connectMobileBroker
 } from "../../network-observation.js";
+import { createAndroidGfxinfoPerformanceBackend } from "./android-gfxinfo-performance.js";
 async function createMobilePerformanceBackend(target, env) {
+  if (resolvePlatform(env) === "android") {
+    return createAndroidGfxinfoPerformanceBackend(env);
+  }
   const { client } = await connectMobileBroker(target, env);
   return createCdpTraceCollector(
     client,