@platformatic/wattpm-pprof-capture 3.28.0-alpha.1 → 3.28.1

package/index.js

@@ -229,7 +229,7 @@ function startIfOverThreshold (type, state, wasRunning = state.profilerStarted)
   }
 }
 
-async function initializeSourceMapper () {
+async function initializeSourceMapper (options = {}) {
   if (sourceMapperInitialized) {
     return
   }
@@ -251,6 +251,19 @@ async function initializeSourceMapper () {
     const debug = process.env.PLT_PPROF_SOURCEMAP_DEBUG === 'true'
     const innerMapper = await SourceMapper.create([appPath], debug)
 
+    // Load additional node_modules sourcemaps if specified
+    if (options.nodeModulesSourceMaps?.length > 0) {
+      const { loadNodeModulesSourceMaps } = await import('./lib/node-modules-sourcemaps.js')
+      const moduleEntries = await loadNodeModulesSourceMaps(
+        appPath,
+        options.nodeModulesSourceMaps,
+        debug
+      )
+      for (const [generatedPath, info] of moduleEntries) {
+        innerMapper.infoMap.set(generatedPath, info)
+      }
+    }
+
     // Wrap the SourceMapper to fix Windows path normalization
     sourceMapper = new SourceMapperWrapper(innerMapper)
 
@@ -280,9 +293,16 @@ export async function startProfiling (options = {}) {
   }
 
   // Initialize source mapper if source maps are requested
-  state.sourceMapsEnabled = options.sourceMaps === true
+  if (options.sourceMaps === undefined) {
+    state.sourceMapsEnabled = process.sourceMapsEnabled
+  } else if (options.sourceMaps === true) {
+    state.sourceMapsEnabled = true
+  }
+
   if (state.sourceMapsEnabled) {
-    await initializeSourceMapper()
+    await initializeSourceMapper({
+      nodeModulesSourceMaps: options.nodeModulesSourceMaps
+    })
   }
 
   state.isCapturing = true

package/lib/node-modules-sourcemaps.js

@@ -0,0 +1,231 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import * as sourceMap from 'source-map'
+
+const MAP_EXT = '.map'
+const MAP_FILE_PATTERN = /\.[cm]?js\.map$/
+
+/**
+ * Check if an error is a non-fatal filesystem error that should be silently ignored.
+ */
+function isNonFatalError (error) {
+  const nonFatalErrors = ['ENOENT', 'EPERM', 'EACCES', 'ELOOP']
+  return error instanceof Error && error.code && nonFatalErrors.includes(error.code)
+}
+
+/**
+ * Async generator that recursively walks a directory looking for .map files.
+ * Similar to @datadog/pprof's walk function but without the node_modules exclusion.
+ */
+async function * walkForMapFiles (dir) {
+  async function * walkRecursive (currentDir) {
+    try {
+      const dirHandle = await fs.opendir(currentDir)
+      for await (const entry of dirHandle) {
+        const entryPath = path.join(currentDir, entry.name)
+        if (entry.isDirectory()) {
+          // Skip .git directories but NOT node_modules (unlike @datadog/pprof)
+          if (entry.name !== '.git') {
+            yield * walkRecursive(entryPath)
+          }
+        } else if (entry.isFile() && MAP_FILE_PATTERN.test(entry.name)) {
+          // Verify the file is readable
+          try {
+            await fs.access(entryPath, fs.constants.R_OK)
+            yield entryPath
+          } catch {
+            // Skip unreadable files
+          }
+        }
+      }
+    } catch (error) {
+      if (!isNonFatalError(error)) {
+        throw error
+      }
+      // Silently ignore non-fatal errors (ENOENT, EPERM, etc.)
+    }
+  }
+  yield * walkRecursive(dir)
+}
+
+/**
+ * Process a single .map file and return the entry for the infoMap.
+ * Returns { generatedPath, info } or null if processing fails.
+ */
+async function processSourceMapFile (mapPath, debug, logger) {
+  if (!mapPath || !mapPath.endsWith(MAP_EXT)) {
+    return null
+  }
+
+  mapPath = path.normalize(mapPath)
+
+  let contents
+  try {
+    contents = await fs.readFile(mapPath, 'utf8')
+  } catch (error) {
+    if (debug && logger) {
+      logger.debug({ mapPath, error: error.message }, 'Could not read source map file')
+    }
+    return null
+  }
+
+  let consumer
+  try {
+    consumer = await new sourceMap.SourceMapConsumer(contents)
+  } catch (error) {
+    if (debug && logger) {
+      logger.debug({ mapPath, error: error.message }, 'Could not parse source map file')
+    }
+    return null
+  }
+
+  // Determine the generated file path
+  // Same logic as @datadog/pprof: try consumer.file first, then basename without .map
+  const dir = path.dirname(mapPath)
+  const generatedPathCandidates = []
+
+  if (consumer.file) {
+    generatedPathCandidates.push(path.resolve(dir, consumer.file))
+  }
+
+  const samePath = path.resolve(dir, path.basename(mapPath, MAP_EXT))
+  if (generatedPathCandidates.length === 0 || generatedPathCandidates[0] !== samePath) {
+    generatedPathCandidates.push(samePath)
+  }
+
+  // Find the first candidate that exists
+  for (const generatedPath of generatedPathCandidates) {
+    try {
+      await fs.access(generatedPath, fs.constants.F_OK)
+      if (debug && logger) {
+        logger.debug({ generatedPath, mapPath }, 'Loaded source map for node_modules file')
+      }
+      return {
+        generatedPath,
+        info: {
+          mapFileDir: dir,
+          mapConsumer: consumer
+        }
+      }
+    } catch {
+      if (debug && logger) {
+        logger.debug({ generatedPath }, 'Generated path does not exist')
+      }
+    }
+  }
+
+  if (debug && logger) {
+    logger.debug({ mapPath }, 'Unable to find generated file for source map')
+  }
+  return null
+}
+
+/**
+ * Resolve a module path from the application directory.
+ * Handles both regular and scoped packages (e.g., 'next' and '@next/next-server').
+ */
+function resolveModulePath (appPath, moduleName) {
+  // Try using require.resolve from the app's context
+  try {
+    const require = createRequire(path.join(appPath, 'package.json'))
+    const modulePath = require.resolve(moduleName)
+    // Get the module's root directory
+    // For regular packages: node_modules/next/dist/file.js -> node_modules/next
+    // For scoped packages: node_modules/@next/next-server/dist/file.js -> node_modules/@next/next-server
+    const nodeModulesIndex = modulePath.lastIndexOf('node_modules')
+    if (nodeModulesIndex === -1) {
+      return null
+    }
+
+    const afterNodeModules = modulePath.substring(nodeModulesIndex + 'node_modules'.length + 1)
+    let moduleRoot
+    if (moduleName.startsWith('@')) {
+      // Scoped package: @scope/package
+      const parts = afterNodeModules.split(path.sep)
+      moduleRoot = path.join(modulePath.substring(0, nodeModulesIndex), 'node_modules', parts[0], parts[1])
+    } else {
+      // Regular package
+      const parts = afterNodeModules.split(path.sep)
+      moduleRoot = path.join(modulePath.substring(0, nodeModulesIndex), 'node_modules', parts[0])
+    }
+
+    return moduleRoot
+  } catch {
+    // Module not found, try walking up from appPath
+  }
+
+  // Fallback: walk up directory tree looking for node_modules
+  let currentDir = appPath
+  while (currentDir !== path.dirname(currentDir)) {
+    const modulePath = path.join(currentDir, 'node_modules', moduleName)
+    try {
+      // Check if the module directory exists synchronously (we're in a sync context here)
+      const stat = require('node:fs').statSync(modulePath)
+      if (stat.isDirectory()) {
+        return modulePath
+      }
+    } catch {
+      // Not found, continue up
+    }
+    currentDir = path.dirname(currentDir)
+  }
+
+  return null
+}
+
+/**
+ * Load source maps from specified node_modules packages.
+ *
+ * @param {string} appPath - The application root directory
+ * @param {string[]} moduleNames - Array of module names to load sourcemaps from (e.g., ['next', '@next/next-server'])
+ * @param {boolean} debug - Whether to enable debug logging
+ * @returns {Promise<Map<string, {mapFileDir: string, mapConsumer: SourceMapConsumer}>>}
+ */
+export async function loadNodeModulesSourceMaps (appPath, moduleNames, debug = false) {
+  const entries = new Map()
+  const logger = globalThis.platformatic?.logger
+
+  if (debug && logger) {
+    logger.debug({ appPath, moduleNames }, 'Loading source maps from node_modules')
+  }
+
+  for (const moduleName of moduleNames) {
+    const modulePath = resolveModulePath(appPath, moduleName)
+    if (!modulePath) {
+      if (logger) {
+        logger.warn({ moduleName }, 'Could not resolve module path for sourcemap loading')
+      }
+      continue
+    }
+
+    if (debug && logger) {
+      logger.debug({ moduleName, modulePath }, 'Scanning module for source maps')
+    }
+
+    let mapCount = 0
+    try {
+      for await (const mapFile of walkForMapFiles(modulePath)) {
+        const entry = await processSourceMapFile(mapFile, debug, logger)
+        if (entry) {
+          entries.set(entry.generatedPath, entry.info)
+          mapCount++
+        }
+      }
+    } catch (error) {
+      if (logger) {
+        logger.warn({ moduleName, error: error.message }, 'Error scanning module for source maps')
+      }
+    }
+
+    if (debug && logger) {
+      logger.debug({ moduleName, mapCount }, 'Finished scanning module for source maps')
+    }
+  }
+
+  if (debug && logger) {
+    logger.debug({ totalMaps: entries.size }, 'Finished loading node_modules source maps')
+  }
+
+  return entries
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/wattpm-pprof-capture",
-  "version": "3.28.0-alpha.1",
+  "version": "3.28.1",
   "description": "pprof profiling capture for wattpm",
   "main": "index.js",
   "type": "module",
@@ -26,8 +26,8 @@
     "neostandard": "^0.12.0",
     "pprof-format": "^2.1.0",
     "typescript": "^5.0.0",
-    "@platformatic/foundation": "3.28.0-alpha.1",
-    "@platformatic/service": "3.28.0-alpha.1"
+    "@platformatic/foundation": "3.28.1",
+    "@platformatic/service": "3.28.1"
   },
   "engines": {
     "node": ">=22.19.0"

package/test/fixtures/node-modules-sourcemap-test/platformatic.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/runtime/2.0.0.json",
+  "entrypoint": "service",
+  "preload": "../../../index.js",
+  "autoload": {
+    "path": "./"
+  },
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0
+  },
+  "logger": {
+    "level": "error"
+  }
+}

package/test/fixtures/node-modules-sourcemap-test/service/platformatic.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/service/2.0.0.json",
+  "server": {
+    "logger": {
+      "level": "warn"
+    }
+  },
+  "plugins": {
+    "paths": [{
+      "path": "plugin.js",
+      "encapsulate": false
+    }]
+  }
+}

package/test/fixtures/node-modules-sourcemap-test/service/plugin.js

@@ -0,0 +1,17 @@
+// Simple plugin that can trigger CPU-intensive work
+// The test uses this to generate profiles while testing nodeModulesSourceMaps option
+
+export default async function (app) {
+  app.get('/', async () => {
+    return { message: 'Hello from Node Modules Sourcemap Test' }
+  })
+
+  app.get('/compute', async () => {
+    // Do some CPU-intensive work to generate profiling samples
+    let result = 0
+    for (let i = 0; i < 1000000; i++) {
+      result += Math.sqrt(i)
+    }
+    return { result }
+  })
+}

package/test/fixtures/sourcemap-config-test/platformatic.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/runtime/3.20.0.json",
+  "entrypoint": "service",
+  "preload": "../../../index.js",
+  "autoload": {
+    "path": "./"
+  },
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0
+  },
+  "logger": {
+    "level": "error"
+  },
+  "sourceMaps": true
+}

package/test/fixtures/sourcemap-config-test/service/platformatic.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/service/2.0.0.json",
+  "server": {
+    "logger": {
+      "level": "warn"
+    }
+  },
+  "plugins": {
+    "paths": [{
+      "path": "dist/plugin.js",
+      "encapsulate": false
+    }]
+  }
+}

package/test/fixtures/sourcemap-config-test/service/plugin.ts

@@ -0,0 +1,71 @@
+import { type FastifyInstance } from 'fastify'
+
+// A function with a distinctive name that we can find in the profile
+// This function allocates significant memory to ensure heap profiler captures samples
+function myTypeScriptFunction(value: number): number {
+  let result = 0
+  const allocations: Array<{ data: number[], metadata: object }> = []
+
+  // Allocate memory in chunks larger than heap profiler sampling interval (512KB)
+  // Each iteration allocates ~1MB to ensure we trigger heap profiler sampling
+  // Reduced to 3 iterations to make test faster while still generating enough samples
+  for (let i = 0; i < 3; i++) {
+    // Allocate a large array (~800KB of numbers)
+    const largeArray = new Array(100000)
+    for (let j = 0; j < largeArray.length; j++) {
+      largeArray[j] = Math.sqrt(j * value)
+      result += largeArray[j]
+    }
+
+    // Allocate objects with metadata
+    const metadata = {
+      index: i,
+      timestamp: Date.now(),
+      value,
+      description: 'Memory allocation for heap profiling test'.repeat(10)
+    }
+
+    allocations.push({ data: largeArray, metadata })
+  }
+
+  // Keep allocations alive until we're done computing
+  return result + allocations.length
+}
+
+export default async function (app: FastifyInstance) {
+  app.get('/', async () => {
+    return { message: 'Hello from TypeScript' }
+  })
+
+  app.get('/compute', async () => {
+    const result = myTypeScriptFunction(42)
+    return { result }
+  })
+
+  app.get('/diagnostic', async () => {
+    const fs = await import('node:fs/promises')
+    const path = await import('node:path')
+    const url = await import('node:url')
+    const serviceDir = path.dirname(url.fileURLToPath(import.meta.url))
+    const pluginJsPath = path.join(serviceDir, 'plugin.js')
+    const pluginMapPath = path.join(serviceDir, 'plugin.js.map')
+
+    const diagnostics = {
+      serviceDir,
+      pluginJsExists: false,
+      pluginMapExists: false
+    }
+
+    try {
+      await fs.access(pluginJsPath)
+      diagnostics.pluginJsExists = true
+    } catch {}
+
+    try {
+      await fs.access(pluginMapPath)
+      diagnostics.pluginMapExists = true
+    } catch {}
+
+    return diagnostics
+  })
+}

package/test/fixtures/sourcemap-config-test/service/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": false
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/test/minimal-sourcemap.test.js

@@ -3,8 +3,10 @@ import { Worker } from 'node:worker_threads'
 import { resolve } from 'node:path'
 import { exec } from 'node:child_process'
 import { promisify } from 'node:util'
+import { platform } from 'node:os'
 
 const execAsync = promisify(exec)
+const isWindows = platform() === 'win32'
 
 test.before(async () => {
   const serviceDir = resolve(import.meta.dirname, 'fixtures/sourcemap-test/service')
@@ -16,7 +18,7 @@ test.before(async () => {
 })
 
 // Test if SourceMapper works in a plain worker thread on Windows
-test('minimal SourceMapper test in worker thread', async (t) => {
+test('minimal SourceMapper test in worker thread', { skip: isWindows }, async (t) => {
   await new Promise((resolve, reject) => {
     const worker = new Worker(new URL('./fixtures/minimal-sourcemap-worker.js', import.meta.url))
 

package/test/node-modules-sourcemap.test.js

@@ -0,0 +1,78 @@
+import assert from 'node:assert'
+import { resolve } from 'node:path'
+import test from 'node:test'
+import { loadNodeModulesSourceMaps } from '../lib/node-modules-sourcemaps.js'
+
+// Unit test for loadNodeModulesSourceMaps
+test('loadNodeModulesSourceMaps should load source maps from next package', async (t) => {
+  // Get the path to the platformatic monorepo root (where next is installed)
+  // From packages/wattpm-pprof-capture/test -> go up 3 levels to reach monorepo root
+  const monorepoRoot = resolve(import.meta.dirname, '../../..')
+
+  // Load source maps from the next package
+  const entries = await loadNodeModulesSourceMaps(monorepoRoot, ['next'], false)
+
+  // Verify that we found source maps
+  assert.ok(entries.size > 0, `Should have found source maps in next package, found ${entries.size}`)
+
+  // Verify the structure of entries
+  for (const [generatedPath, info] of entries) {
+    assert.ok(typeof generatedPath === 'string', 'Generated path should be a string')
+    assert.ok(generatedPath.endsWith('.js') || generatedPath.endsWith('.cjs') || generatedPath.endsWith('.mjs'),
+      `Generated path should end with .js, .cjs, or .mjs: ${generatedPath}`)
+    assert.ok(info.mapFileDir, 'Info should have mapFileDir')
+    assert.ok(info.mapConsumer, 'Info should have mapConsumer')
+    assert.ok(typeof info.mapConsumer.originalPositionFor === 'function',
+      'mapConsumer should have originalPositionFor method')
+  }
+
+  // Log some stats
+  console.log(`Loaded ${entries.size} source maps from next package`)
+})
+
+// Unit test for loadNodeModulesSourceMaps with scoped package
+test('loadNodeModulesSourceMaps should handle non-existent packages gracefully', async (t) => {
+  const monorepoRoot = resolve(import.meta.dirname, '../../..')
+
+  // Try to load from a non-existent package
+  const entries = await loadNodeModulesSourceMaps(monorepoRoot, ['non-existent-package-12345'], false)
+
+  // Should return empty map without throwing
+  assert.strictEqual(entries.size, 0, 'Should return empty map for non-existent package')
+})
+
+// Unit test for loadNodeModulesSourceMaps with multiple packages
+test('loadNodeModulesSourceMaps should load source maps from multiple packages', async (t) => {
+  const monorepoRoot = resolve(import.meta.dirname, '../../..')
+
+  // Load from multiple packages (next has source maps, fastify typically doesn't)
+  const entries = await loadNodeModulesSourceMaps(monorepoRoot, ['next', 'fastify'], false)
+
+  // Should have at least the next package's source maps
+  assert.ok(entries.size > 0, 'Should have found source maps')
+})
+
+// Test that source map data can be used for lookups
+test('loaded source maps should have valid mapping data', async (t) => {
+  const monorepoRoot = resolve(import.meta.dirname, '../../..')
+
+  const entries = await loadNodeModulesSourceMaps(monorepoRoot, ['next'], false)
+  assert.ok(entries.size > 0, 'Should have source maps to test')
+
+  // Pick a random entry and verify we can do a lookup
+  const [generatedPath, info] = entries.entries().next().value
+
+  // Try to get original position for line 1, column 0
+  const pos = info.mapConsumer.originalPositionFor({ line: 1, column: 0 })
+
+  // The position might be null if line 1 col 0 has no mapping,
+  // but the function should not throw
+  assert.ok(pos !== undefined, 'originalPositionFor should return a result')
+
+  // Verify the sources array exists
+  assert.ok(info.mapConsumer.sources, 'mapConsumer should have sources')
+  assert.ok(Array.isArray(info.mapConsumer.sources), 'sources should be an array')
+
+  console.log(`Tested lookup on ${generatedPath}`)
+  console.log(`  Sources: ${info.mapConsumer.sources.length}`)
+})

package/test/sourcemap.test.js

@@ -61,10 +61,7 @@ function decodeAndValidateProfile (encodedProfile, checkLocations) {
   return profile
 }
 
-// Build TypeScript service once before all tests
-test.before(async () => {
-  const serviceDir = resolve(import.meta.dirname, 'fixtures/sourcemap-test/service')
-
+async function compile (serviceDir) {
   // Build the TypeScript (dependencies are in parent package devDependencies)
   try {
     await execAsync('npx tsc', { cwd: serviceDir, timeout: 30000 })
@@ -82,10 +79,22 @@ test.before(async () => {
   } catch (err) {
     throw new Error(`Build artifacts not found: ${err.message}. Plugin: ${pluginPath}, Map: ${mapPath}`)
   }
+}
+
+// Build TypeScript service once before all tests
+test.before(async () => {
+  const dirs = [
+    resolve(import.meta.dirname, 'fixtures/sourcemap-test/service'),
+    resolve(import.meta.dirname, 'fixtures/sourcemap-config-test/service')
+  ]
+
+  for (const dir of dirs) {
+    await compile(dir)
+  }
 })
 
-async function createApp (t) {
-  const configFile = resolve(import.meta.dirname, 'fixtures/sourcemap-test/platformatic.json')
+async function createApp (t, config = 'fixtures/sourcemap-test/platformatic.json') {
+  const configFile = resolve(import.meta.dirname, config)
 
   // Ensure tmp directory exists
   const { mkdir } = await import('node:fs/promises')
@@ -108,7 +117,7 @@ async function createApp (t) {
   return { app, url }
 }
 
-test('sourcemaps should be initialized and profiling should work with TypeScript', async t => {
+test('sourcemaps should be initialized and profiling should work with TypeScript', { skip: process.platform === 'win32' }, async t => {
   const { app, url } = await createApp(t)
 
   // Verify service is running
@@ -173,7 +182,7 @@ test('sourcemaps should be initialized and profiling should work with TypeScript
   await app.sendCommandToApplication('service', 'stopProfiling')
 })
 
-test('sourcemaps should work with heap profiling', async t => {
+test('sourcemaps should work with heap profiling', { skip: process.platform === 'win32' }, async t => {
   const { app, url } = await createApp(t)
 
   // Start heap profiling with source maps enabled
@@ -205,3 +214,68 @@ test('sourcemaps should work with heap profiling', async t => {
 
   await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
 })
+
+test('sourcemaps should be initialized and profiling should work with TypeScript if enabled via config file', { skip: process.platform === 'win32' }, async t => {
+  const { app, url } = await createApp(t, 'fixtures/sourcemap-config-test/platformatic.json')
+
+  // Verify service is running
+  const res = await request(`${url}/`)
+  const json = await res.body.json()
+  assert.strictEqual(res.statusCode, 200)
+  assert.strictEqual(json.message, 'Hello from TypeScript')
+
+  // Verify sourcemap files exist in service directory
+  const diagRes = await request(`${url}/diagnostic`, { headersTimeout: 10000, bodyTimeout: 10000 })
+  const diag = await diagRes.body.json()
+  assert.strictEqual(diag.pluginMapExists, true, `Sourcemap file should exist at ${diag.serviceDir}/plugin.js.map`)
+
+  // Start profiling with sufficient duration to ensure we capture samples
+  // Enable source maps to resolve TypeScript locations
+  await app.sendCommandToApplication('service', 'startProfiling', { durationMillis: 5000 })
+
+  // Wait for profiler to actually start
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isProfilerRunning
+  }, 2000)
+
+  // Make requests spread over time to ensure continuous CPU activity during profiling
+  // Use shorter interval and add timeout to prevent hanging
+  let consecutiveFailures = 0
+  let intervalStopped = false
+  const requestInterval = setInterval(() => {
+    if (intervalStopped) return
+
+    request(`${url}/compute`, { headersTimeout: 30000, bodyTimeout: 30000 })
+      .then(() => {
+        consecutiveFailures = 0
+      })
+      .catch((err) => {
+        consecutiveFailures++
+
+        // If we get 3 consecutive connection failures, the service likely crashed
+        if (consecutiveFailures >= 3 && (err.message.includes('ECONNREFUSED') || err.message.includes('ECONNRESET'))) {
+          intervalStopped = true
+          clearInterval(requestInterval)
+          throw new Error(`Service crashed - ${consecutiveFailures} consecutive connection failures: ${err.message}`)
+        }
+      })
+  }, 300)
+
+  // Wait for profile to be captured
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.hasProfile
+  }, 10000)
+
+  clearInterval(requestInterval)
+
+  // Get the profile - this should succeed with SourceMapper initialized
+  const encodedProfile = await app.sendCommandToApplication('service', 'getLastProfile')
+  const profile = decodeAndValidateProfile(encodedProfile, true)
+
+  // Verify sourcemaps are working by checking for .ts file extensions
+  verifyTypeScriptFilesInProfile(profile)
+
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})