libuv-size

Author: szegedi

packages/dd-trace/src/profiling/exporters/event_serializer.js

@@ -5,23 +5,7 @@
 const os = require('os')
 const perf = require('perf_hooks').performance
 const version = require('../../../../../package.json').version
-const { getEnvironmentVariable } = require('../../config-helper')
-
-const libuvThreadPoolSize = (() => {
-  const ss = getEnvironmentVariable('UV_THREADPOOL_SIZE')
-  if (ss === undefined) {
-    // Backend will apply the default size based on Node version.
-    return
-  }
-  // libuv uses atoi to parse the value, which is almost the same as parseInt, except that parseInt
-  // will return NaN on invalid input, while atoi will return 0. This is handled at return.
-  const s = Number.parseInt(ss)
-  // We don't interpret the value further here in the library. Backend will interpret the number
-  // based on Node version. In all currently known Node versions, 0 results in 1 worker thread,
-  // negative values (because they're assigned to an unsigned int) become very high positive values,
-  // and the value is finally capped at 1024.
-  return Number.isNaN(s) ? 0 : s
-})()
+const { availableParallelism, libuvThreadPoolSize } = require('../libuv-size')
 
 class EventSerializer {
   constructor ({ env, host, service, version, libraryInjected, activation } = {}) {
@@ -77,10 +61,7 @@ class EventSerializer {
           version
         },
         runtime: {
-          // os.availableParallelism only available in node 18.14.0/19.4.0 and above
-          available_processors: typeof os.availableParallelism === 'function'
-            ? os.availableParallelism()
-            : os.cpus().length,
+          available_processors: availableParallelism(),
           // Using `nodejs` for consistency with the existing `runtime` tag.
           // Note that the event `family` property uses `node`, as that's what's
           // proscribed by the Intake API, but that's an internal enum and is

packages/dd-trace/src/profiling/libuv-size.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { getEnvironmentVariable } = require('../config-helper')
+const os = require('node:os')
+
+function getLibuvThreadPoolSize (envVar) {
+  if (envVar === undefined) {
+    return
+  }
+  // libuv uses atoi to parse the value, which is almost the same as parseInt, except that parseInt
+  // will return NaN on invalid input, while atoi will return 0. This is handled at return.
+  const s = Number.parseInt(envVar, 10)
+  // We don't interpret the value further here in the library. Backend will interpret the number
+  // based on Node version.
+  return Number.isNaN(s) ? 0 : s
+}
+
+const libuvThreadPoolSize = getLibuvThreadPoolSize(getEnvironmentVariable('UV_THREADPOOL_SIZE'))
+
+function getEffectiveLibuvThreadCount (size) {
+  // In all currently known Node versions, 0 results in 1 worker thread, negative values (because
+  // they're assigned to an unsigned int) become very high positive values, and the value is finally
+  // capped at 1024.
+  if (size === undefined) {
+    return 4
+  } else if (size < 0 || size > 1024) {
+    return 1024
+  } else if (size === 0) {
+    return 1
+  }
+  return size
+}
+
+const effectiveLibuvThreadCount = getEffectiveLibuvThreadCount(libuvThreadPoolSize)
+
+function availableParallelism () {
+  // os.availableParallelism only available in node 18.14.0/19.4.0 and above
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  return typeof os.availableParallelism === 'function' ? os.availableParallelism() : os.cpus().length
+}
+
+module.exports = {
+  availableParallelism,
+  effectiveLibuvThreadCount,
+  libuvThreadPoolSize,
+  // Only used for testing
+  getLibuvThreadPoolSize,
+  getEffectiveLibuvThreadCount
+}

packages/dd-trace/test/profiling/libuv-size.spec.js

@@ -0,0 +1,50 @@
+'use strict'
+
+require('../setup/tap')
+
+const { expect } = require('chai')
+const libuvSize = require('../../src/profiling/libuv-size')
+
+describe('libuv-size', function () {
+  describe('getLibuvThreadPoolSize should return', function () {
+    it('undefined if no environment variable is set', function () {
+      expect(libuvSize.getLibuvThreadPoolSize()).to.equal(undefined)
+    })
+
+    it('0 for an empty environment variable', function () {
+      expect(libuvSize.getLibuvThreadPoolSize('')).to.equal(0)
+    })
+
+    it('0 for an invalid environment variable', function () {
+      expect(libuvSize.getLibuvThreadPoolSize('invalid')).to.equal(0)
+    })
+
+    it('a parsed numeric value', function () {
+      expect(libuvSize.getLibuvThreadPoolSize('100')).to.equal(100)
+    })
+  })
+
+  describe('getEffectiveLibuvThreadPoolSize should return', function () {
+    it('the libuv thread pool size if set', function () {
+      expect(libuvSize.getEffectiveLibuvThreadCount(100)).to.equal(100)
+    })
+
+    it('the default value if not set', function () {
+      expect(libuvSize.getEffectiveLibuvThreadCount()).to.equal(4)
+    })
+
+    it('1 if set to 0', function () {
+      expect(libuvSize.getEffectiveLibuvThreadCount(0)).to.equal(1)
+    })
+
+    it('1024 if set to a negative value', function () {
+      expect(libuvSize.getEffectiveLibuvThreadCount(-1)).to.equal(1024)
+      expect(libuvSize.getEffectiveLibuvThreadCount(-100000)).to.equal(1024)
+    })
+
+    it('1024 if set to a very large value', function () {
+      expect(libuvSize.getEffectiveLibuvThreadCount(1025)).to.equal(1024)
+      expect(libuvSize.getEffectiveLibuvThreadCount(100000)).to.equal(1024)
+    })
+  })
+})