@platformatic/watt-extra 1.7.1-alpha.7 → 1.8.1-alpha.1

package/.claude/settings.local.json

@@ -1,11 +1,20 @@
 {
   "permissions": {
     "allow": [
-      "Bash(node --test-only:*)",
+      "Read(//work/workspaces/workspace-platformatic/platformatic/**)",
+      "Bash(npx borp:*)",
+      "Bash(timeout 30 npx borp -c 1 --timeout=20000 ./test/trigger-flamegraphs.test.js)",
+      "Bash(xargs cat:*)",
+      "Bash(pnpm install)",
+      "Bash(find:*)",
+      "Bash(cat:*)",
+      "WebFetch(domain:github.com)",
       "Bash(node --test:*)",
-      "Bash(for i in {1..3})",
-      "Bash(do echo \"=== Run $i ===\")",
-      "Bash(done)"
+      "Bash(for i in 1 2 3)",
+      "Bash(do echo \"Run $i:\")",
+      "Bash(done)",
+      "Bash(git stash:*)",
+      "Bash(echo:*)"
     ],
     "deny": [],
     "ask": []

package/.github/workflows/test.yml

@@ -35,7 +35,7 @@ jobs:
         node-version: [22.x, 24.x]
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: pnpm/action-setup@v4.2.0
         with:
           version: 10

package/lib/watt.js

@@ -94,6 +94,49 @@ class Watt {
     }
   }
 
+  async updateInstanceConfig (instanceConfig) {
+    this.#logger.info({ applicationId: instanceConfig?.applicationId }, 'Updating instance config after ICC recovery')
+
+    const previousConfig = this.#instanceConfig
+    this.#instanceConfig = instanceConfig
+
+    // If we didn't have a config before and now we do, apply runtime updates
+    if (!previousConfig && instanceConfig && this.runtime) {
+      // Update undici interceptors
+      try {
+        const undiciConfig = this.#getUndiciConfig()
+        await this.runtime.updateUndiciInterceptors?.(undiciConfig)
+        this.#logger.info('Updated undici interceptors after ICC recovery')
+      } catch (err) {
+        this.#logger.error({ err }, 'Failed to update undici interceptors after ICC recovery')
+      }
+
+      // Update metrics config if runtime supports it
+      if (typeof this.runtime.updateMetricsConfig === 'function') {
+        try {
+          // Get current metrics config set by #configureRuntime
+          const runtimeConfig = this.runtime.getRuntimeConfig(true)
+          const currentMetrics = runtimeConfig.metrics || {}
+
+          // Merge with ICC updates
+          const updatedMetrics = {
+            ...currentMetrics,
+            labels: {
+              ...currentMetrics.labels,
+              applicationId: instanceConfig.applicationId
+            },
+            applicationLabel: instanceConfig.applicationMetricsLabel ?? currentMetrics.applicationLabel
+          }
+
+          await this.runtime.updateMetricsConfig(updatedMetrics)
+          this.#logger.info('Updated metrics config after ICC recovery')
+        } catch (err) {
+          this.#logger.error({ err }, 'Failed to update metrics config after ICC recovery')
+        }
+      }
+    }
+  }
+
   async updateSharedContext (context) {
     this.#sharedContext = context
     await this.runtime?.updateSharedContext?.({ context })
@@ -351,30 +394,61 @@ class Watt {
       !!this.#instanceConfig?.enableOpenTelemetry &&
       !!this.#instanceConfig?.iccServices?.riskEngine?.url
 
-    // We need to always set an opentelemetry config to pass a telemetry
-    // applicationName to render a taxonomy diagram
-    config.telemetry = config.telemetry ?? {
-      enabled: enableOpenTelemetry,
-      applicationName: `${this.#applicationName}`,
-      skip: [
-        { method: 'GET', path: '/documentation' },
-        { method: 'GET', path: '/documentation/json' }
-      ],
-      exporter: {
-        type: 'otlp',
-        options: {
-          url:
-            this.#instanceConfig?.iccServices?.riskEngine?.url + '/v1/traces',
-          headers: {
-            'x-platformatic-application-id': this.#instanceConfig?.applicationId
-          },
-          keepAlive: true,
-          httpAgentOptions: {
-            rejectUnauthorized: false
-          }
+    const iccExporter = {
+      type: 'otlp',
+      options: {
+        url: this.#instanceConfig?.iccServices?.riskEngine?.url + '/v1/traces',
+        headers: {
+          'x-platformatic-application-id': this.#instanceConfig?.applicationId
+        },
+        keepAlive: true,
+        httpAgentOptions: {
+          rejectUnauthorized: false
         }
       }
     }
+
+    const defaultSkip = [
+      { method: 'GET', path: '/documentation' },
+      { method: 'GET', path: '/documentation/json' }
+    ]
+
+    // If user has no telemetry config, create default
+    if (!config.telemetry) {
+      config.telemetry = {
+        enabled: enableOpenTelemetry,
+        applicationName: `${this.#applicationName}`,
+        skip: defaultSkip,
+        exporter: iccExporter
+      }
+      return
+    }
+
+    // Merge with existing telemetry config
+    // Always set applicationName for taxonomy diagrams (overrides user's value)
+    config.telemetry.applicationName = `${this.#applicationName}`
+
+    // If ICC telemetry is enabled, add ICC exporter to user's exporters
+    if (enableOpenTelemetry) {
+      const userExporter = config.telemetry.exporter
+      if (!userExporter) {
+        // No user exporter, just use ICC
+        config.telemetry.exporter = iccExporter
+      } else if (Array.isArray(userExporter)) {
+        // User has array of exporters, add ICC to the list
+        config.telemetry.exporter = [...userExporter, iccExporter]
+      } else {
+        // User has single exporter, convert to array with both
+        config.telemetry.exporter = [userExporter, iccExporter]
+      }
+    }
+
+    // Merge skip patterns
+    if (config.telemetry.skip) {
+      config.telemetry.skip = [...config.telemetry.skip, ...defaultSkip]
+    } else {
+      config.telemetry.skip = defaultSkip
+    }
   }
 
   #configureHttpCaching (config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/watt-extra",
-  "version": "1.7.1-alpha.7",
+  "version": "1.8.1-alpha.1",
   "description": "The Platformatic runtime manager",
   "type": "module",
   "scripts": {

package/plugins/alerts.js

@@ -1,9 +1,6 @@
 import { request } from 'undici'
 
 async function alerts (app, _opts) {
-  const pauseEluThreshold = app.env.PLT_FLAMEGRAPHS_PAUSE_ELU_TRESHOLD
-  const pauseTimeout = app.env.PLT_FLAMEGRAPHS_PAUSE_TIMEOUT
-
   const healthCache = [] // It's OK to have this in memory, this is per-pod.
   const podHealthWindow =
     app.instanceConfig?.scaler?.podHealthWindow || 60 * 1000
@@ -13,6 +10,10 @@ async function alerts (app, _opts) {
   const lastServicesAlertTime = {}
   const workerStartTimes = new Map() // Track per-worker start times for grace period
 
+  // Store listener references for cleanup
+  let workerStartedListener = null
+  let healthListener = null
+
   async function setupAlerts () {
     const scalerAlgorithmVersion = app.instanceConfig?.scaler?.version ?? 'v1'
     if (scalerAlgorithmVersion !== 'v1') {
@@ -40,17 +41,30 @@ async function alerts (app, _opts) {
       return
     }
 
+    const healthEventName = app.watt.runtimeSupportsNewHealthMetrics()
+      ? 'application:worker:health:metrics'
+      : 'application:worker:health'
+
+    // Remove old listeners if they exist (for ICC recovery scenario)
+    if (workerStartedListener) {
+      runtime.removeListener('application:worker:started', workerStartedListener)
+    }
+    if (healthListener) {
+      runtime.removeListener(healthEventName, healthListener)
+    }
+
     // Default start time for workers that started before the listener was registered
     const pluginStartTime = Date.now()
 
     // Listen for worker start events to track start times
-    runtime.on('application:worker:started', (workerInfo) => {
+    workerStartedListener = (workerInfo) => {
       const workerId = workerInfo?.id
       if (workerId) {
         workerStartTimes.set(workerId, Date.now())
         app.log.debug({ workerId }, 'Worker started, tracking for grace period')
       }
-    })
+    }
+    runtime.on('application:worker:started', workerStartedListener)
 
     const processHealthInfo = async (healthInfo) => {
       if (!healthInfo) {
@@ -64,11 +78,6 @@ async function alerts (app, _opts) {
       const healthWithTimestamp = { ...healthInfo, timestamp, service: serviceId }
       delete healthWithTimestamp.healthConfig // we don't need to store this
 
-      const elu = healthInfo.currentHealth.elu
-      if (elu >= pauseEluThreshold) {
-        app.pauseProfiling({ serviceId, timeout: pauseTimeout })
-      }
-
       healthCache.push(healthWithTimestamp)
 
       const cutoffTime = timestamp - podHealthWindow
@@ -144,14 +153,18 @@ async function alerts (app, _opts) {
 
         const alert = await body.json()
 
-        app.requestFlamegraphs({ serviceIds: [serviceId], alertId: alert.id })
-          .catch(err => app.log.error({ err }, 'Failed to send a flamegraph'))
+        app.sendFlamegraphs({
+          workerIds: [workerId],
+          alertId: alert.id
+        }).catch(err => {
+          app.log.error({ err }, 'Failed to send a flamegraph')
+        })
       }
     }
 
     if (app.watt.runtimeSupportsNewHealthMetrics()) {
       // Runtime >= 3.18.0: Listen to health:metrics
-      runtime.on('application:worker:health:metrics', async (health) => {
+      healthListener = async (health) => {
         if (!health) {
           app.log.error('No health info received')
           return
@@ -181,11 +194,12 @@ async function alerts (app, _opts) {
         }
 
         await processHealthInfo(healthInfo)
-      })
+      }
     } else {
       // Runtime < 3.18.0:
-      runtime.on('application:worker:health', processHealthInfo)
+      healthListener = processHealthInfo
     }
+    runtime.on(healthEventName, healthListener)
   }
   app.setupAlerts = setupAlerts
 }

package/plugins/env.js

@@ -19,10 +19,10 @@ const schema = {
     PLT_CACHE_CONFIG: { type: 'string' },
     PLT_DISABLE_FLAMEGRAPHS: { type: 'boolean', default: false },
     PLT_FLAMEGRAPHS_INTERVAL_SEC: { type: 'number', default: 60 },
+    PLT_FLAMEGRAPHS_ELU_THRESHOLD: { type: 'number', default: 0.4 },
     PLT_FLAMEGRAPHS_GRACE_PERIOD: { type: 'number', default: 3000 },
-    PLT_FLAMEGRAPHS_PAUSE_ELU_TRESHOLD: { type: 'number', default: 0.95 },
-    PLT_FLAMEGRAPHS_PAUSE_TIMEOUT: { type: 'number', default: 5 * 60 * 1000 },
-    PLT_FLAMEGRAPHS_STATES_REFRESH_INTERVAL: { type: 'number', default: 10 * 1000 },
+    PLT_FLAMEGRAPHS_ATTEMPT_TIMEOUT: { type: 'number', default: 10000 },
+    PLT_FLAMEGRAPHS_CACHE_CLEANUP_INTERVAL: { type: 'number', default: 120000 },
     PLT_JWT_EXPIRATION_OFFSET_SEC: { type: 'number', default: 60 },
     PLT_UPDATES_RECONNECT_INTERVAL_SEC: { type: 'number', default: 1 },
     PLT_ELU_HEALTH_SIGNAL_THRESHOLD: { type: 'number', default: 0.8 },