Add slice_name to error handler

Author: MitchDickinson

packages/cli-kit/src/public/node/error-handler.test.ts

@@ -1,4 +1,12 @@
-import {errorHandler, cleanStackFrameFilePath, addBugsnagMetadata, sendErrorToBugsnag} from './error-handler.js'
+import {
+  errorHandler,
+  cleanStackFrameFilePath,
+  addBugsnagMetadata,
+  sendErrorToBugsnag,
+  computeAllowedSliceNames,
+  registerCleanBugsnagErrorsFromWithinPlugins,
+} from './error-handler.js'
+import * as metadata from './metadata.js'
 import {ciPlatform, cloudEnvironment, isUnitTest, macAddress} from './context/local.js'
 import {mockAndCaptureOutput} from './testing/output.js'
 import * as error from './error.js'
@@ -8,16 +16,23 @@ import {settings} from '@oclif/core'
 import {beforeEach, describe, expect, test, vi} from 'vitest'
 
 const onNotify = vi.fn()
+let lastBugsnagEvent: {addMetadata: ReturnType<typeof vi.fn>} | undefined
 
 vi.mock('process')
 vi.mock('@bugsnag/js', () => {
   return {
     default: {
       notify: (reportedError: any, args: any, callback: any) => {
         onNotify(reportedError)
+        if (typeof args === 'function') {
+          const event = {addMetadata: vi.fn()}
+          lastBugsnagEvent = event as any
+          args(event)
+        }
         callback(null)
       },
       isStarted: () => true,
+      addOnError: vi.fn(),
     },
   }
 })
@@ -39,6 +54,7 @@ beforeEach(() => {
   vi.mocked(hashString).mockReturnValue('hashed-macaddress')
   vi.mocked(isUnitTest).mockReturnValue(true)
   onNotify.mockClear()
+  lastBugsnagEvent = undefined
   vi.mocked(settings).debug = false
   vi.mocked(isLocalEnvironment).mockReturnValue(false)
 })
@@ -207,4 +223,86 @@ describe('sends errors to Bugsnag', () => {
     expect(res.error).toEqual(toThrow)
     expect(mockOutput.debug()).toMatch('Error reporting to Bugsnag: Error: Bugsnag is down')
   })
+
+  test('logs and suppresses when allowed slice names not initialized', async () => {
+    // Reset module state to ensure ALLOWED_SLICE_NAMES is undefined
+    vi.resetModules()
+
+    await metadata.addSensitiveMetadata(() => ({
+      commandStartOptions: {startTime: Date.now(), startCommand: 'app dev', startArgs: []},
+    }))
+
+    const mockOutput = mockAndCaptureOutput()
+
+    const res = await sendErrorToBugsnag(new Error('boom'), 'unexpected_error')
+    expect(res.reported).toEqual(false)
+    expect(mockOutput.debug()).toMatch(
+      'Error reporting to Bugsnag: Error: Internal error: allowed slice names not initialized.',
+    )
+  })
+
+  test('attaches custom metadata with allowed slice_name when startCommand is present', async () => {
+    // Initialize allowed slice names to include 'app' using a mock config
+    await registerCleanBugsnagErrorsFromWithinPlugins({
+      // Minimal shape required by the function
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      commands: [{id: 'app:dev'}] as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      plugins: new Map() as any,
+    } as unknown as any)
+
+    await metadata.addSensitiveMetadata(() => ({
+      commandStartOptions: {startTime: Date.now(), startCommand: 'app dev', startArgs: []},
+    }))
+
+    await sendErrorToBugsnag(new Error('boom'), 'unexpected_error')
+
+    expect(lastBugsnagEvent).toBeDefined()
+    expect(lastBugsnagEvent!.addMetadata).toHaveBeenCalledWith('custom', {slice_name: 'app'})
+  })
+
+  test('does not attach custom slice_name when startCommand is missing', async () => {
+    await metadata.addSensitiveMetadata(() => ({
+      commandStartOptions: {startTime: Date.now(), startCommand: undefined as unknown as string, startArgs: []},
+    }))
+
+    await sendErrorToBugsnag(new Error('boom'), 'unexpected_error')
+
+    expect(lastBugsnagEvent).toBeDefined()
+    const calls = (lastBugsnagEvent!.addMetadata as any).mock.calls as any[]
+    const customCall = calls.find(([section]: [string]) => section === 'custom')
+    expect(customCall).toBeUndefined()
+  })
+
+  test('defaults slice_name to cli when first word not allowed', async () => {
+    // Initialize allowed slice names to known set that does not include 'version'
+    await registerCleanBugsnagErrorsFromWithinPlugins({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      commands: [{id: 'app:dev'}] as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      plugins: new Map() as any,
+    } as unknown as any)
+
+    await metadata.addSensitiveMetadata(() => ({
+      commandStartOptions: {startTime: Date.now(), startCommand: 'version', startArgs: []},
+    }))
+
+    await sendErrorToBugsnag(new Error('boom'), 'unexpected_error')
+
+    expect(lastBugsnagEvent).toBeDefined()
+    expect(lastBugsnagEvent!.addMetadata).toHaveBeenCalledWith('custom', {slice_name: 'cli'})
+  })
+})
+
+describe('computeAllowedSliceNames', () => {
+  test('derives first tokens from command IDs', () => {
+    const names = computeAllowedSliceNames({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      commands: [{id: 'app:build'}, {id: 'theme:pull'}, {id: 'version'}, {id: undefined as any}] as any,
+    } as unknown as any)
+    expect(names.has('app')).toBe(true)
+    expect(names.has('theme')).toBe(true)
+    expect(names.has('version')).toBe(true)
+    expect(names.has('store')).toBe(false)
+  })
 })

packages/cli-kit/src/public/node/error-handler.ts

@@ -21,6 +21,27 @@ import StackTracey from 'stacktracey'
 import Bugsnag, {Event} from '@bugsnag/js'
 import {realpath} from 'fs/promises'
 
+// Allowed slice names for error analytics grouping. This is populated from the
+// loaded OCLIF config at runtime.
+let ALLOWED_SLICE_NAMES: Set<string> | undefined
+
+export function computeAllowedSliceNames(config: Interfaces.Config): Set<string> {
+  const names = new Set<string>()
+  const commands = (config.commands ?? []) as Array<{id?: string}>
+  for (const cmd of commands) {
+    // Command IDs are typically colon-separated (e.g. app:build). We take the first token.
+    const id = (cmd as unknown as {id?: string}).id
+    if (!id) continue
+    const first = id.split(':')[0]?.trim()
+    if (first) names.add(first)
+  }
+  return names
+}
+
+export function initializeAllowedSliceNames(config: Interfaces.Config): void {
+  ALLOWED_SLICE_NAMES = computeAllowedSliceNames(config)
+}
+
 export async function errorHandler(
   error: Error & {exitCode?: number | undefined},
   config?: Interfaces.Config,
@@ -126,6 +147,19 @@ export async function sendErrorToBugsnag(
         const eventHandler = (event: Event) => {
           event.severity = 'error'
           event.unhandled = unhandled
+          // Attach command metadata so we know which CLI command triggered the error
+          const {commandStartOptions} = metadata.getAllSensitiveMetadata()
+          const {startCommand} = commandStartOptions ?? {}
+          if (startCommand) {
+            if (!ALLOWED_SLICE_NAMES) {
+              throw new Error(
+                'Internal error: allowed slice names not initialized. Ensure registerCleanBugsnagErrorsFromWithinPlugins() ran.',
+              )
+            }
+            const firstWord = startCommand.trim().split(/\s+/)[0] ?? 'cli'
+            const sliceName = ALLOWED_SLICE_NAMES.has(firstWord) ? firstWord : 'cli'
+            event.addMetadata('custom', {slice_name: sliceName})
+          }
         }
         const errorHandler = (error: unknown) => {
           if (error) {
@@ -182,6 +216,8 @@ export function cleanStackFrameFilePath({
  *
  */
 export async function registerCleanBugsnagErrorsFromWithinPlugins(config: Interfaces.Config): Promise<void> {
+  // Update allowed slice names dynamically based on loaded commands
+  initializeAllowedSliceNames(config)
   // Bugsnag have their own plug-ins that use this private field
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any