@platformatic/wattpm-pprof-capture 3.24.0-alpha0 → 3.25.0

package/index.js

@@ -2,6 +2,7 @@ import { time, heap, SourceMapper } from '@datadog/pprof'
 import { performance } from 'node:perf_hooks'
 import { workerData } from 'node:worker_threads'
 import { NoProfileAvailableError, NotEnoughELUError, ProfilingAlreadyStartedError, ProfilingNotStartedError } from './lib/errors.js'
+import { SourceMapperWrapper } from './lib/source-mapper-wrapper.js'
 
 const kITC = Symbol.for('plt.runtime.itc')
 
@@ -9,55 +10,6 @@ const kITC = Symbol.for('plt.runtime.itc')
 let sourceMapper = null
 let sourceMapperInitialized = false
 
-/**
- * Wrapper around SourceMapper that fixes Windows path normalization issues.
- *
- * On Windows, V8 profiler returns paths like `file:///D:/path/to/file.js`.
- * The @datadog/pprof library removes `file://` leaving `/D:/path/to/file.js`,
- * but SourceMapper stores paths as `D:\path\to\file.js`.
- *
- * This wrapper normalizes Windows paths to match the internal format.
- */
-class SourceMapperWrapper {
-  constructor (innerMapper) {
-    this.innerMapper = innerMapper
-    this.debug = innerMapper.debug
-  }
-
-  /**
-   * Normalize Windows-style paths from V8 profiler to match SourceMapper format.
-   * Handles paths like `/D:/path/to/file.js` -> `D:\path\to\file.js`
-   */
-  normalizePath (filePath) {
-    if (process.platform !== 'win32') {
-      return filePath
-    }
-
-    // Handle paths like /D:/path/to/file -> D:\path\to\file
-    // This happens because pprof removes 'file://' from 'file:///D:/path/to/file'
-    if (filePath.startsWith('/') && filePath.length > 2 && filePath[2] === ':') {
-      // Remove leading slash and convert forward slashes to backslashes
-      return filePath.slice(1).replace(/\//g, '\\')
-    }
-
-    // Also convert any forward slashes to backslashes on Windows
-    return filePath.replace(/\//g, '\\')
-  }
-
-  hasMappingInfo (inputPath) {
-    const normalized = this.normalizePath(inputPath)
-    return this.innerMapper.hasMappingInfo(normalized)
-  }
-
-  mappingInfo (location) {
-    const normalized = {
-      ...location,
-      file: this.normalizePath(location.file)
-    }
-    return this.innerMapper.mappingInfo(normalized)
-  }
-}
-
 // Track ELU globally (shared across all profiler types)
 let lastELU = null
 let previousELU = performance.eventLoopUtilization()
@@ -79,6 +31,7 @@ const profilingState = {
   cpu: {
     isCapturing: false,
     latestProfile: null,
+    latestProfileTimestamp: null,
     captureInterval: null,
     durationMillis: null,
     eluThreshold: null,
@@ -90,6 +43,7 @@ const profilingState = {
   heap: {
     isCapturing: false,
     latestProfile: null,
+    latestProfileTimestamp: null,
     captureInterval: null,
     durationMillis: null,
     eluThreshold: null,
@@ -124,6 +78,7 @@ function scheduleLastProfileCleanup (state) {
   if (state.options?.durationMillis) {
     state.clearProfileTimeout = setTimeout(() => {
       state.latestProfile = undefined
+      state.latestProfileTimestamp = null
       state.clearProfileTimeout = null
     }, state.options.durationMillis)
     state.clearProfileTimeout.unref()
@@ -196,6 +151,7 @@ function stopProfiler (type, state) {
   scheduleLastProfileCleanup(state)
   unscheduleProfileRotation(state)
   state.profilerStarted = false
+  state.latestProfileTimestamp = Date.now()
 
   if (type === 'heap') {
     // Get the profile before stopping
@@ -378,6 +334,7 @@ export function getLastProfile (options = {}) {
     const profiler = getProfiler(type)
     // Get heap profile with sourceMapper if enabled and available
     state.latestProfile = (state.sourceMapsEnabled && sourceMapper) ? profiler.profile(undefined, sourceMapper) : profiler.profile()
+    state.latestProfileTimestamp = Date.now()
   }
 
   // Check if we have a profile
@@ -405,7 +362,8 @@ export function getProfilingState (options = {}) {
     isProfilerRunning: state.profilerStarted,
     isPausedBelowThreshold: state.eluThreshold != null && !state.profilerStarted,
     lastELU: lastELU?.utilization,
-    eluThreshold: state.eluThreshold
+    eluThreshold: state.eluThreshold,
+    latestProfileTimestamp: state.latestProfileTimestamp
   }
 }
 

package/lib/source-mapper-wrapper.js

@@ -0,0 +1,65 @@
+/**
+ * Wrapper around SourceMapper that fixes Windows path normalization issues.
+ *
+ * On Windows, V8 profiler returns paths like `file:///D:/path/to/file.js`.
+ * The @datadog/pprof library removes `file://` leaving `/D:/path/to/file.js`,
+ * but SourceMapper stores paths as `D:\path\to\file.js`.
+ *
+ * This wrapper normalizes Windows paths to match the internal format.
+ */
+export class SourceMapperWrapper {
+  constructor (innerMapper) {
+    this.innerMapper = innerMapper
+    this.debug = innerMapper.debug
+  }
+
+  /**
+   * Normalize Windows-style paths from V8 profiler to match SourceMapper format.
+   * Handles paths like `/D:/path/to/file.js` -> `D:\path\to\file.js`
+   */
+  normalizePath (filePath) {
+    if (process.platform !== 'win32') {
+      return filePath
+    }
+
+    // Handle paths like /D:/path/to/file -> D:\path\to\file
+    // This happens because pprof removes 'file://' from 'file:///D:/path/to/file'
+    if (filePath.startsWith('/') && filePath.length > 2 && filePath[2] === ':') {
+      // Remove leading slash and convert forward slashes to backslashes
+      return filePath.slice(1).replace(/\//g, '\\')
+    }
+
+    // Also convert any forward slashes to backslashes on Windows
+    return filePath.replace(/\//g, '\\')
+  }
+
+  hasMappingInfo (inputPath) {
+    const normalized = this.normalizePath(inputPath)
+    return this.innerMapper.hasMappingInfo(normalized)
+  }
+
+  mappingInfo (location) {
+    const normalized = {
+      ...location,
+      file: this.normalizePath(location.file)
+    }
+
+    const protocols = ['webpack:']
+    const mappedInfo = this.innerMapper.mappingInfo(normalized)
+    // The @datadog/pprof SourceMapper uses path.resolve() which treats webpack: URLs
+    // as relative paths, creating malformed paths like:
+    // /path/to/.next/server/app/api/heavy/webpack:/next/src/app/api/heavy/route.js
+    // We need to extract just the webpack: URL part
+
+    for (const protocol of protocols) {
+      if (!mappedInfo.file) continue
+
+      const webpackIndex = mappedInfo.file.indexOf(protocol)
+      if (webpackIndex > 0) {
+        // Extract just the webpack: URL
+        mappedInfo.file = mappedInfo.file.substring(webpackIndex)
+      }
+    }
+    return mappedInfo
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/wattpm-pprof-capture",
-  "version": "3.24.0-alpha0",
+  "version": "3.25.0",
   "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.24.0-alpha0",
-    "@platformatic/service": "3.24.0-alpha0"
+    "@platformatic/service": "3.25.0",
+    "@platformatic/foundation": "3.25.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/test/source-mapper-wrapper.test.js

@@ -0,0 +1,43 @@
+import { test } from 'node:test'
+import { deepStrictEqual } from 'node:assert'
+import { SourceMapperWrapper } from '../lib/source-mapper-wrapper.js'
+
+class MockSourceMapper {
+  constructor (mapper) {
+    this.mapper = mapper
+  }
+
+  mappingInfo (location) {
+    return this.mapper(location)
+  }
+}
+
+test('should correctly map webpack paths', async () => {
+  const appPath = '/Users/ivan-tymoshenko/projects/platformatic/leads-demo/web/next'
+  const info = {
+    file: `${appPath}/.next/server/app/api/heavy/route.js`,
+    line: 1,
+    column: 42,
+    name: 'a'
+  }
+
+  const mapper = () => {
+    return {
+      file: `${appPath}/.next/server/app/api/heavy/webpack:/next/src/app/api/heavy/route.js`,
+      name: 'fibonacci',
+      line: 6,
+      column: 12
+    }
+  }
+
+  const innerMapper = new MockSourceMapper(mapper)
+  const sourceMapper = new SourceMapperWrapper(innerMapper)
+
+  const mappedInfo = sourceMapper.mappingInfo(info)
+  deepStrictEqual(mappedInfo, {
+    file: 'webpack:/next/src/app/api/heavy/route.js',
+    name: 'fibonacci',
+    line: 6,
+    column: 12
+  })
+})

package/test/watt-pprof-capture.test.js

@@ -647,3 +647,124 @@ test('profiling with eluThreshold should continue rotating while above threshold
   await request(`${url}/cpu-intensive/stop`, { method: 'POST' })
   await app.sendCommandToApplication('service', 'stopProfiling')
 })
+
+test('latestProfileTimestamp should be set after profile rotation', async t => {
+  const { app } = await createApp(t)
+
+  // Check initial state - timestamp should be null
+  const initialState = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.strictEqual(initialState.latestProfileTimestamp, null, 'Timestamp should be null before profiling')
+
+  // Start profiling with rotation
+  await app.sendCommandToApplication('service', 'startProfiling', { durationMillis: 200 })
+
+  // Wait for first rotation
+  await new Promise(resolve => setTimeout(resolve, 250))
+
+  // Get state and verify timestamp is set
+  const stateAfterRotation = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.ok(stateAfterRotation.latestProfileTimestamp != null, 'Timestamp should be set after rotation')
+  assert.ok(typeof stateAfterRotation.latestProfileTimestamp === 'number', 'Timestamp should be a number')
+  assert.ok(stateAfterRotation.latestProfileTimestamp <= Date.now(), 'Timestamp should not be in the future')
+  assert.ok(stateAfterRotation.latestProfileTimestamp > Date.now() - 5000, 'Timestamp should be recent')
+
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})
+
+test('latestProfileTimestamp should be set after stopProfiling', async t => {
+  const { app } = await createApp(t)
+
+  // Start profiling without rotation
+  await app.sendCommandToApplication('service', 'startProfiling', {})
+
+  // Get state before stop - timestamp should be null (no rotation occurred)
+  const stateBeforeStop = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.strictEqual(stateBeforeStop.latestProfileTimestamp, null, 'Timestamp should be null before stop')
+
+  // Stop profiling
+  const beforeStopTime = Date.now()
+  await app.sendCommandToApplication('service', 'stopProfiling')
+  const afterStopTime = Date.now()
+
+  // Get state after stop - timestamp should be set
+  const stateAfterStop = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.ok(stateAfterStop.latestProfileTimestamp != null, 'Timestamp should be set after stopProfiling')
+  assert.ok(stateAfterStop.latestProfileTimestamp >= beforeStopTime, 'Timestamp should be >= time before stop')
+  assert.ok(stateAfterStop.latestProfileTimestamp <= afterStopTime, 'Timestamp should be <= time after stop')
+})
+
+test('latestProfileTimestamp should be cleared after profile cleanup timeout', async t => {
+  const { app } = await createApp(t)
+
+  // Start profiling with short rotation interval
+  await app.sendCommandToApplication('service', 'startProfiling', { durationMillis: 200 })
+
+  // Wait for first rotation
+  await new Promise(resolve => setTimeout(resolve, 250))
+
+  // Verify timestamp is set
+  const stateWithProfile = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.ok(stateWithProfile.latestProfileTimestamp != null, 'Timestamp should be set after rotation')
+  assert.ok(stateWithProfile.hasProfile, 'Should have profile')
+
+  // Stop profiling - this schedules cleanup after durationMillis (200ms)
+  await app.sendCommandToApplication('service', 'stopProfiling')
+
+  // Wait for cleanup timeout (durationMillis after stop)
+  await new Promise(resolve => setTimeout(resolve, 300))
+
+  // Verify timestamp is cleared after cleanup
+  const stateAfterCleanup = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.strictEqual(stateAfterCleanup.latestProfileTimestamp, null, 'Timestamp should be cleared after cleanup')
+  assert.ok(!stateAfterCleanup.hasProfile, 'Profile should be cleared')
+})
+
+test('latestProfileTimestamp should be set for heap profiling', async t => {
+  const { app } = await createApp(t)
+
+  // Check initial state for heap - timestamp should be null
+  const initialState = await app.sendCommandToApplication('service', 'getProfilingState', { type: 'heap' })
+  assert.strictEqual(initialState.latestProfileTimestamp, null, 'Heap timestamp should be null before profiling')
+
+  // Start heap profiling
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'heap' })
+
+  // Wait a bit
+  await new Promise(resolve => setTimeout(resolve, 100))
+
+  // Get last profile (for heap, this captures a snapshot)
+  const beforeGetProfile = Date.now()
+  await app.sendCommandToApplication('service', 'getLastProfile', { type: 'heap' })
+  const afterGetProfile = Date.now()
+
+  // Verify timestamp is set after getLastProfile for heap
+  const stateAfterGet = await app.sendCommandToApplication('service', 'getProfilingState', { type: 'heap' })
+  assert.ok(stateAfterGet.latestProfileTimestamp != null, 'Heap timestamp should be set after getLastProfile')
+  assert.ok(stateAfterGet.latestProfileTimestamp >= beforeGetProfile, 'Timestamp should be >= time before get')
+  assert.ok(stateAfterGet.latestProfileTimestamp <= afterGetProfile, 'Timestamp should be <= time after get')
+
+  await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
+})
+
+test('latestProfileTimestamp should update with each rotation', async t => {
+  const { app } = await createApp(t)
+
+  // Start profiling with short rotation interval
+  await app.sendCommandToApplication('service', 'startProfiling', { durationMillis: 200 })
+
+  // Wait for first rotation
+  await new Promise(resolve => setTimeout(resolve, 250))
+  const stateAfterFirst = await app.sendCommandToApplication('service', 'getProfilingState')
+  const firstTimestamp = stateAfterFirst.latestProfileTimestamp
+  assert.ok(firstTimestamp != null, 'Timestamp should be set after first rotation')
+
+  // Wait for second rotation
+  await new Promise(resolve => setTimeout(resolve, 250))
+  const stateAfterSecond = await app.sendCommandToApplication('service', 'getProfilingState')
+  const secondTimestamp = stateAfterSecond.latestProfileTimestamp
+
+  // Second timestamp should be greater than first
+  assert.ok(secondTimestamp > firstTimestamp, 'Timestamp should update with each rotation')
+
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})