@platformatic/watt-extra 0.1.0

package/test/patch-config.test.js

@@ -0,0 +1,434 @@
+import assert from 'node:assert'
+import { test } from 'node:test'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { randomUUID } from 'node:crypto'
+import { request } from 'undici'
+import { setUpEnvironment, startICC, installDeps } from './helper.js'
+import { start } from '../index.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+test('should spawn a service app settings labels for metrics', async (t) => {
+  const applicationName = 'test-application'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    enableOpenTelemetry: true,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const mainConfig = app.wattpro.runtime.getRuntimeConfig(true)
+
+  const { metrics, telemetry } = mainConfig
+
+  const expectedTelemetry = {
+    enabled: true,
+    applicationName: 'test-application',
+    skip: [
+      {
+        method: 'GET',
+        path: '/documentation',
+      },
+      {
+        method: 'GET',
+        path: '/documentation/json',
+      },
+    ],
+    exporter: {
+      type: 'otlp',
+      options: {
+        url: 'http://127.0.0.1:3000/risk-service/v1/traces',
+        headers: {
+          'x-platformatic-application-id': applicationId,
+        },
+        keepAlive: true,
+        httpAgentOptions: {
+          rejectUnauthorized: false,
+        },
+      },
+    },
+  }
+  assert.deepStrictEqual(telemetry, expectedTelemetry)
+
+  const expectedMetrics = {
+    server: 'hide',
+    defaultMetrics: {
+      enabled: true,
+    },
+    hostname: '127.0.0.1',
+    port: 9090,
+    labels: {
+      serviceId: 'main',
+      instanceId: app.instanceId,
+      applicationId,
+    },
+  }
+  assert.deepStrictEqual(metrics, expectedMetrics)
+})
+
+test('should configure system resources', async (t) => {
+  const applicationName = 'test-next'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-next')
+
+  await installDeps(t, applicationPath, ['@platformatic/next', 'next'])
+  const { execa } = await import('execa')
+  await execa(join(__dirname, '../node_modules/.bin/plt'), ['build'], {
+    cwd: applicationPath,
+  })
+
+  const iccConfig = {
+    resources: {
+      threads: 1,
+      heap: 256,
+      services: [
+        {
+          name: 'next',
+          threads: 3,
+          heap: 200,
+        },
+      ],
+    },
+  }
+  const icc = await startICC(t, { applicationId, applicationName, iccConfig })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+  const config = await app.wattpro.runtime.getRuntimeConfig(true)
+
+  // Check generic resources
+  assert.strictEqual(config.workers, 1)
+  assert.strictEqual(config.health.maxHeapTotal, 256 * Math.pow(1024, 2))
+
+  // Check system resources
+  assert.strictEqual(config.applications[0].workers, 3)
+  assert.strictEqual(
+    config.applications[0].health.maxHeapTotal,
+    200 * Math.pow(1024, 2)
+  )
+})
+
+test('should remove server https configs', async (t) => {
+  const appName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-service')
+
+  await installDeps(t, applicationPath)
+
+  const icc = await startICC(t, {
+    applicationId,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+    PLT_CONTROL_PLANE_URL: 'http://127.0.0.1:3002',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  {
+    const mainConfig = app.wattpro.runtime.getRuntimeConfig(true)
+    const { server } = mainConfig
+    assert.strictEqual(server.https, undefined)
+  }
+
+  {
+    const runtimeConfig = await app.wattpro.runtime.getRuntimeConfig(true)
+
+    const { server } = runtimeConfig
+    assert.strictEqual(server.https, undefined)
+  }
+})
+
+test('should configure health options', async (t) => {
+  const appName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-service')
+
+  await installDeps(t, applicationPath)
+
+  const icc = await startICC(t, {
+    applicationId,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const runtimeConfig = await app.wattpro.runtime.getRuntimeConfig(true)
+
+  const { health } = runtimeConfig
+  assert.strictEqual(health.enabled, true)
+  assert.strictEqual(health.interval, 1000)
+  assert.strictEqual(health.maxUnhealthyChecks, 30)
+})
+
+test('should call updateServicesResources with maxHeapTotal', async (t) => {
+  const appName = 'test-update-resources'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-service')
+
+  await installDeps(t, applicationPath)
+
+  const icc = await startICC(t, {
+    applicationId,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const updateCalls = []
+  const originalUpdateServicesResources =
+    app.wattpro.runtime.updateServicesResources
+  app.wattpro.runtime.updateServicesResources = async (resourceUpdates) => {
+    updateCalls.push(resourceUpdates)
+    if (originalUpdateServicesResources) {
+      return originalUpdateServicesResources.call(
+        app.wattpro.runtime,
+        resourceUpdates
+      )
+    }
+  }
+
+  const config = {
+    resources: {
+      services: [
+        { name: 'main', threads: 2, heap: 512 },
+        { name: 'service-1', threads: 1, heap: 256 },
+      ],
+    },
+  }
+
+  await app.wattpro.applyIccConfigUpdates(config)
+
+  assert.strictEqual(
+    updateCalls.length,
+    1,
+    'updateServicesResources should be called once'
+  )
+
+  const resourceUpdates = updateCalls[0]
+  assert.strictEqual(
+    resourceUpdates.length,
+    2,
+    'Should have updates for 2 services'
+  )
+
+  assert.strictEqual(resourceUpdates[0].service, 'main')
+  assert.strictEqual(resourceUpdates[0].workers, 2)
+  assert.strictEqual(resourceUpdates[0].health.maxHeapTotal, '512MB')
+
+  assert.strictEqual(resourceUpdates[1].service, 'service-1')
+  assert.strictEqual(resourceUpdates[1].workers, 1)
+  assert.strictEqual(resourceUpdates[1].health.maxHeapTotal, '256MB')
+})
+
+test('should handle updateServicesResources with different heap sizes', async (t) => {
+  const appName = 'test-heap-sizes'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-service')
+
+  await installDeps(t, applicationPath)
+
+  const icc = await startICC(t, {
+    applicationId,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const updateCalls = []
+  app.wattpro.runtime.updateServicesResources = async (resourceUpdates) => {
+    updateCalls.push(resourceUpdates)
+  }
+
+  const configs = [
+    {
+      resources: {
+        services: [
+          { name: 'small-service', threads: 1, heap: 128 },
+          { name: 'large-service', threads: 4, heap: 2048 },
+        ],
+      },
+    },
+  ]
+
+  for (const config of configs) {
+    await app.wattpro.applyIccConfigUpdates(config)
+  }
+
+  assert.strictEqual(updateCalls.length, 1)
+
+  const resourceUpdates = updateCalls[0]
+  assert.strictEqual(resourceUpdates[0].health.maxHeapTotal, '128MB')
+  assert.strictEqual(resourceUpdates[1].health.maxHeapTotal, '2048MB')
+})
+
+test('should handle updateServicesResources error gracefully', async (t) => {
+  const appName = 'test-update-error'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-service')
+
+  await installDeps(t, applicationPath)
+
+  const icc = await startICC(t, {
+    applicationId,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  let errorThrown = false
+  app.wattpro.runtime.updateServicesResources = async (resourceUpdates) => {
+    assert.strictEqual(resourceUpdates[0].health.maxHeapTotal, '256MB')
+    errorThrown = true
+    throw new Error('Mock update error')
+  }
+
+  const config = {
+    resources: {
+      services: [{ name: 'test-service', threads: 1, heap: 256 }],
+    },
+  }
+
+  await app.wattpro.applyIccConfigUpdates(config)
+
+  assert.strictEqual(
+    errorThrown,
+    true,
+    'updateServicesResources should have been called and thrown an error'
+  )
+})
+
+test('should not set opentelemetry if it is disabled', async (t) => {
+  const applicationName = 'test-application'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    enableOpenTelemetry: false,
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  // main config
+  const { statusCode, body } = await request('http://127.0.0.1:3042/config')
+  assert.strictEqual(statusCode, 200)
+
+  const expectedTelemetry = {
+    enabled: false,
+    applicationName: 'test-application-main',
+    skip: [
+      {
+        method: 'GET',
+        path: '/documentation',
+      },
+      {
+        method: 'GET',
+        path: '/documentation/json',
+      },
+    ],
+    exporter: {
+      type: 'otlp',
+      options: {
+        url: 'http://127.0.0.1:3000/risk-service/v1/traces',
+        headers: {
+          'x-platformatic-application-id': applicationId,
+        },
+        keepAlive: true,
+        httpAgentOptions: {
+          rejectUnauthorized: false,
+        },
+      },
+    },
+  }
+  const mainConfig = await body.json()
+  assert.deepStrictEqual(mainConfig.telemetry, expectedTelemetry)
+})

package/test/scheduler.test.js

@@ -0,0 +1,71 @@
+import assert from 'node:assert'
+import { test } from 'node:test'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { randomUUID } from 'node:crypto'
+import { start } from '../index.js'
+import {
+  setUpEnvironment,
+  startICC,
+  installDeps
+} from './helper.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+test('should spawn a runtime disabling all the scheduler jobs', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-scheduler')
+
+  await installDeps(t, applicationPath)
+
+  let savedWattJob = null
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    saveWattJob: (job) => {
+      savedWattJob = job
+    }
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000'
+  })
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const config = await app.wattpro.runtime.getRuntimeConfig()
+
+  const { scheduler } = config
+
+  // The scheduler should be disabled
+  const expectedSchedulerConfig = [{
+    enabled: false,
+    name: 'test',
+    callbackUrl: 'http://localhost:3000',
+    cron: '*/5 * * * *',
+    method: 'GET',
+    maxRetries: 3
+  }]
+
+  assert.deepStrictEqual(scheduler, expectedSchedulerConfig)
+
+  // ICC is called to save the job
+  const expectedWattJob = {
+    name: 'test',
+    callbackUrl: 'http://localhost:3000',
+    schedule: '*/5 * * * *',
+    method: 'GET',
+    maxRetries: 3,
+    applicationId
+  }
+  assert.deepEqual(savedWattJob, expectedWattJob)
+})

package/test/send-to-icc-retry.test.js

@@ -0,0 +1,138 @@
+import assert from 'node:assert'
+import { test } from 'node:test'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import buildApp from '../app.js'
+import pino from 'pino'
+import {
+  setUpEnvironment
+} from './helper.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+// Create a null logger for tests
+const logger = pino({
+  level: 'silent'
+})
+
+// Helper to close resources after each test
+const closeResources = async (app) => {
+  if (app && typeof app.close === 'function') {
+    try {
+      await app.close()
+    } catch (err) {}
+  }
+}
+
+test('should retry sending info to ICC with exponential backoff', async (t) => {
+  const applicationName = 'test-app'
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+  const retryInterval = 50 // Small interval for test
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+    PLT_ICC_RETRY_TIME: retryInterval
+  })
+
+  const app = await buildApp(logger)
+  t.after(async () => closeResources(app))
+
+  // Mock failure for the first 2 calls, then succeed
+  let callCount = 0
+  const retryTimes = []
+  let lastCallTime = Date.now()
+
+  app.sendToICC = () => {
+    const now = Date.now()
+    if (callCount > 0) {
+      // Calculate actual delay between calls
+      retryTimes.push(now - lastCallTime)
+    }
+    lastCallTime = now
+
+    callCount++
+    if (callCount <= 2) {
+      throw new Error('Mock ICC connection failure')
+    }
+    return true
+  }
+
+  await app.sendToICCWithRetry()
+  assert.strictEqual(callCount, 3, 'ICC should be called 3 times (1 initial + 2 retries)')
+  assert.ok(retryTimes[0] >= retryInterval, 'First retry should wait at least the base retry interval')
+  assert.ok(retryTimes[1] > retryTimes[0], 'Second retry should have longer delay due to exponential backoff')
+})
+
+test('should continue retrying until success within max attempts', async (t) => {
+  const applicationName = 'test-app'
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+  const retryInterval = 10 // Very small interval for fast test
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+    PLT_ICC_RETRY_TIME: retryInterval
+  })
+
+  const app = await buildApp(logger)
+  t.after(async () => closeResources(app))
+  let callCount = 0
+  const succeedAfter = 5 // Succeed after 5 attempts
+
+  const retryTimes = []
+  let lastCallTime = Date.now()
+
+  app.sendToICC = () => {
+    const now = Date.now()
+    if (callCount > 0) {
+      retryTimes.push(now - lastCallTime)
+    }
+    lastCallTime = now
+
+    callCount++
+    if (callCount <= succeedAfter) {
+      throw new Error(`Mock ICC connection failure (attempt ${callCount})`)
+    }
+    return true
+  }
+
+  await app.sendToICCWithRetry()
+  assert.strictEqual(callCount, succeedAfter + 1, `ICC should be called ${succeedAfter + 1} times (1 initial + ${succeedAfter} retries)`)
+
+  for (let i = 1; i < retryTimes.length; i++) {
+    assert.ok(
+      retryTimes[i] > retryTimes[i - 1],
+      `Retry interval should increase: ${retryTimes[i]} > ${retryTimes[i - 1]}`
+    )
+  }
+})
+
+test('should not retry if first attempt succeeds', async (t) => {
+  const applicationName = 'test-app'
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+  const retryInterval = 100 // Small interval for test
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000',
+    PLT_ICC_RETRY_TIME: retryInterval
+  })
+
+  const app = await buildApp(logger)
+  t.after(async () => closeResources(app))
+
+  let callCount = 0
+  app.sendToICC = () => {
+    callCount++
+    return true
+  }
+
+  await app.sendToICCWithRetry()
+  assert.strictEqual(callCount, 1, 'ICC should be called only once')
+})