Clean up profiler-cli counter internals

- Group counters under their process by counter.pid, as the timeline does.
- Add a getCommittedRangeCounterSampleSum selector and use it for the total.
- Drop the unused labelKey from counter stats; the CLI has no localization.
- Cover counter nesting with profile-query unit tests instead of an old fixture.

Author: fatadel

profiler-cli/schemas.txt

@@ -32,7 +32,7 @@ CounterSummary:
     unit, graphType,
     color, pid, mainThreadIndex, mainThreadHandle, mainThreadName,
     rangeSampleCount,
-    stats: [{ source, label, labelKey?, value, formattedValue, carbon? }]
+    stats: [{ source, label, value, formattedValue, carbon? }]
   }
 
 profiler-cli counter list --json

profiler-cli/src/test/integration/counter.test.ts

@@ -17,7 +17,6 @@ import {
 import type {
   CounterListResult,
   CounterInfoResult,
-  ProfileInfoResult,
   WithContext,
 } from '../../protocol';
 
@@ -97,27 +96,6 @@ describe('profiler-cli counter commands', () => {
     expect(parsed.stats.some((s) => s.source === 'count-range')).toBe(true);
   });
 
-  it('profile info lists counters under their process', async () => {
-    await cli(ctx, ['load', PROFILE_WITH_COUNTER]);
-
-    const result = await cli(ctx, ['profile', 'info']);
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain('c-0');
-    expect(result.stdout).toContain('Memory');
-  });
-
-  it('profile info --json nests counters in their owning process', async () => {
-    await cli(ctx, ['load', PROFILE_WITH_COUNTER]);
-
-    const result = await cli(ctx, ['profile', 'info', '--json']);
-    const parsed = JSON.parse(result.stdout) as WithContext<ProfileInfoResult>;
-
-    const counters = parsed.processes.flatMap((p) => p.counters ?? []);
-    expect(counters).toHaveLength(1);
-    expect(counters[0].counterHandle).toBe('c-0');
-  });
-
   it('counter list reports when a profile has no counters', async () => {
     await cli(ctx, ['load', PROFILE_WITHOUT_COUNTER]);
 

src/profile-query/formatters/counter-info.ts

@@ -7,10 +7,8 @@ import {
   getProfileRootRange,
   getCounters,
   getCounterSelectors,
-  getCommittedRange,
   getMeta,
 } from 'firefox-profiler/selectors/profile';
-import { getSampleIndexRangeForSelection } from 'firefox-profiler/profile-logic/profile-data';
 import {
   formatBytes,
   formatNumber,
@@ -29,7 +27,6 @@ import type {
   CounterIndex,
   CounterTooltipDataSource,
   CounterTooltipFormat,
-  CounterSamplesTable,
   ProfileMeta,
 } from 'firefox-profiler/types';
 import type { Store } from '../../types/store';
@@ -50,19 +47,6 @@ const RANGE_AGGREGATE_SOURCES: Set<CounterTooltipDataSource> = new Set([
   'committed-range-total',
 ]);
 
-function sumCountOverRange(
-  samples: CounterSamplesTable,
-  start: number,
-  end: number
-): number {
-  const [begin, finish] = getSampleIndexRangeForSelection(samples, start, end);
-  let sum = 0;
-  for (let i = begin; i < finish; i++) {
-    sum += samples.count[i];
-  }
-  return sum;
-}
-
 /**
  * Format a resolved counter value exactly as the timeline tooltip does, minus
  * the React/localization wrapping. Only the range-aggregate sources reach this,
@@ -126,7 +110,6 @@ function collectCounterStats(
   const selectors = getCounterSelectors(counterIndex);
   const counter = selectors.getCounter(state);
   const accumulated = selectors.getAccumulateCounterSamples(state);
-  const committedRange = getCommittedRange(state);
   const meta = getMeta(state);
 
   const stats: CounterStat[] = [];
@@ -144,11 +127,7 @@ function collectCounterStats(
     const value =
       row.source === 'count-range'
         ? accumulated.countRange
-        : sumCountOverRange(
-            counter.samples,
-            committedRange.start,
-            committedRange.end
-          );
+        : selectors.getCommittedRangeCounterSampleSum(state);
 
     const { formattedValue, carbon } = formatCounterRowValue(
       value,
@@ -158,7 +137,6 @@ function collectCounterStats(
     stats.push({
       source: row.source,
       label: row.label,
-      labelKey: row.labelKey,
       value,
       formattedValue,
       carbon,

src/profile-query/formatters/profile-info.ts

@@ -32,8 +32,7 @@ function applySearchFilter(
 
   for (const process of processes) {
     const processMatches =
-      process.name.toLowerCase().includes(query) ||
-      String(process.pid).includes(query);
+      process.name.toLowerCase().includes(query) || process.pid.includes(query);
 
     const matchingThreads = processMatches
       ? process.threads
@@ -113,10 +112,9 @@ export function collectProfileInfo(
   const countersByPid = new Map<string, CounterSummary[]>();
   (getCounters(state) ?? []).forEach((_, index) => {
     const counter = collectCounterSummary(store, threadMap, index);
-    const pid = String(profile.threads[counter.mainThreadIndex].pid);
-    const list = countersByPid.get(pid) ?? [];
+    const list = countersByPid.get(counter.pid) ?? [];
     list.push(counter);
-    countersByPid.set(pid, list);
+    countersByPid.set(counter.pid, list);
   });
 
   const processesData: ProfileInfoResult['processes'] = processesToShow.map(
@@ -152,7 +150,7 @@ export function collectProfileInfo(
           cpuMs: thread.cpuMs,
         })),
         remainingThreads: processItem.remainingThreads,
-        counters: countersByPid.get(String(processItem.pid)),
+        counters: countersByPid.get(processItem.pid),
       };
     }
   );

src/profile-query/types.ts

@@ -679,7 +679,6 @@ export type ThreadPageLoadResult = {
 export type CounterStat = {
   source: CounterTooltipDataSource;
   label: string;
-  labelKey?: string;
   value: number;
   formattedValue: string;
   carbon?: string;

src/selectors/profile.ts

@@ -16,6 +16,7 @@ import {
   getFriendlyThreadName,
   processCounter,
   getInclusiveSampleIndexRangeForSelection,
+  getSampleIndexRangeForSelection,
   computeInnerWindowIDToTabMap,
   computeTabToThreadIndexesMap,
   computeStackTableFromRawStackTable,
@@ -379,6 +380,23 @@ function _createCounterSelectors(counterIndex: CounterIndex) {
       )
   );
 
+  const getCommittedRangeCounterSampleSum: Selector<number> = createSelector(
+    getCounter,
+    getCommittedRange,
+    (counter, range) => {
+      const [begin, end] = getSampleIndexRangeForSelection(
+        counter.samples,
+        range.start,
+        range.end
+      );
+      let sum = 0;
+      for (let i = begin; i < end; i++) {
+        sum += counter.samples.count[i];
+      }
+      return sum;
+    }
+  );
+
   return {
     getCounter,
     getDescription,
@@ -387,6 +405,7 @@ function _createCounterSelectors(counterIndex: CounterIndex) {
     getMaxCounterSampleCountPerMs,
     getMaxRangeCounterSampleCountPerMs,
     getCommittedRangeCounterSampleRange,
+    getCommittedRangeCounterSampleSum,
   };
 }
 

src/test/unit/profile-query/profile-querier.test.ts

@@ -17,7 +17,10 @@
  */
 
 import { ProfileQuerier } from 'firefox-profiler/profile-query';
-import { getProfileFromTextSamples } from '../../fixtures/profiles/processed-profile';
+import {
+  getProfileFromTextSamples,
+  getCounterForThread,
+} from '../../fixtures/profiles/processed-profile';
 import { getProfileRootRange } from 'firefox-profiler/selectors/profile';
 import { storeWithProfile } from '../../fixtures/stores';
 
@@ -344,6 +347,67 @@ describe('ProfileQuerier', function () {
     });
   });
 
+  describe('counters', function () {
+    function profileWithMemoryCounter() {
+      const { profile } = getProfileFromTextSamples(`
+        0  1  2
+        A  A  A
+        B  B  B
+      `);
+      const counter = getCounterForThread(profile.threads[0], 0, {
+        name: 'malloc',
+        category: 'Memory',
+        hasCountNumber: true,
+      });
+      profile.counters = [counter];
+      return { profile, counter };
+    }
+
+    function querierFor(profile: Parameters<typeof storeWithProfile>[0]) {
+      const store = storeWithProfile(profile);
+      return new ProfileQuerier(store, getProfileRootRange(store.getState()));
+    }
+
+    it('counterList returns a schema-driven summary per counter', async function () {
+      const { profile } = profileWithMemoryCounter();
+      const result = await querierFor(profile).counterList();
+
+      expect(result.counters).toHaveLength(1);
+      expect(result.counters[0].counterHandle).toBe('c-0');
+      expect(result.counters[0].label).toBe('Memory');
+      expect(
+        result.counters[0].stats.some((s) => s.source === 'count-range')
+      ).toBe(true);
+    });
+
+    it('profileInfo nests each counter under its owning process', async function () {
+      const { profile, counter } = profileWithMemoryCounter();
+      const info = await querierFor(profile).profileInfo();
+
+      const owningProcess = info.processes.find((p) => p.pid === counter.pid);
+      expect(owningProcess).toBeDefined();
+      expect(owningProcess!.counters?.map((c) => c.counterHandle)).toEqual([
+        'c-0',
+      ]);
+    });
+
+    it('counterInfo resolves a counter by handle', async function () {
+      const { profile } = profileWithMemoryCounter();
+      const info = await querierFor(profile).counterInfo('c-0');
+
+      expect(info.counterHandle).toBe('c-0');
+      expect(info.description).toBe('My Description');
+      expect(info.sampleCount).toBeGreaterThan(0);
+    });
+
+    it('counterInfo throws for an unknown handle', async function () {
+      const { profile } = profileWithMemoryCounter();
+      await expect(querierFor(profile).counterInfo('c-9')).rejects.toThrow(
+        'Unknown counter c-9'
+      );
+    });
+  });
+
   describe('threadSamples', function () {
     it('searches all roots when choosing the heaviest stack', async function () {
       const { profile } = getProfileFromTextSamples(`