perf(sdk-trace-base): use Uint8Array for browser RandomIdGenerator

CHANGELOG.md

@@ -20,6 +20,8 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2
 
 ### :house: Internal
 
+* perf(sdk-trace-base): use Uint8Array for browser RandomIdGenerator [#6209](https://github.com/open-telemetry/opentelemetry-js/pull/6209) @overbalance
+
 ## 2.5.0
 
 ### :bug: Bug Fixes

codecov.yml

@@ -1,6 +1,12 @@
 codecov:
   notify:
     require_ci_to_pass: no
+ignore:
+  - "*.js"
+  - "**/karma.*.js"
+  - "**/.eslintrc.js"
+  - "**/*.config.*"
+  - "scripts/"
 comment:
   layout: "header, changes, diff, files"
   behavior: default

eslint.base.js

@@ -64,6 +64,7 @@ module.exports = {
         "projectService": true
       },
       rules: {
+        "no-console": "warn",
         "no-empty": "off",
         "@typescript-eslint/ban-ts-ignore": "off",
         "@typescript-eslint/no-unsafe-function-type": ["warn"],

karma.webpack.js

@@ -37,6 +37,12 @@ module.exports = {
       // Thanks to https://stackoverflow.com/a/65018686/14239942
       // NOTE: I wish there was a better way as this pollutes the tests with a defined 'process' global.
       process: 'process/browser.js'
+    }),
+    // Benchmark.js checks for AMD's define function which doesn't exist in webpack.
+    // NOTE: This pollutes tests with a defined 'self.define' global.
+    new webpack.BannerPlugin({
+      banner: 'self.define = self.define || Object.assign(function(){}, {amd: false});',
+      raw: true
     })
   ],
   module: {

package.json

@@ -16,6 +16,7 @@
     "test:browser": "nx run-many -t test:browser",
     "test:webworker": "nx run-many -t test:webworker",
     "test:bench": "nx run-many -t test:bench",
+    "test:bench:browser": "nx run-many -t test:bench:browser -- --verbose",
     "predocs-test": "npm run docs",
     "docs": "typedoc --readme none && touch docs/.nojekyll",
     "docs-deploy": "gh-pages --dotfiles --dist docs",

packages/opentelemetry-sdk-trace-base/test/performance/benchmark/index.js → packages/opentelemetry-sdk-trace-base/karma.bench.js

@@ -14,5 +14,18 @@
  * limitations under the License.
  */
 
-require('./span');
-require('./BatchSpanProcessor');
+const karmaWebpackConfig = require('../../karma.webpack');
+const karmaBaseConfig = require('../../karma.base');
+
+module.exports = config => {
+  config.set(
+    Object.assign({}, karmaBaseConfig, {
+      webpack: karmaWebpackConfig,
+      files: ['test/browser/**/*.bench.ts'],
+      preprocessors: {
+        'test/browser/**/*.bench.ts': ['webpack'],
+      },
+      browserNoActivityTimeout: 120000,
+    })
+  );
+};

packages/opentelemetry-sdk-trace-base/package.json

@@ -20,7 +20,8 @@
     "test": "nyc mocha 'test/**/*.test.ts' --exclude 'test/browser/**/*.ts'",
     "test:browser": "karma start --single-run",
     "test:webworker": "karma start karma.worker.js --single-run",
-    "test:bench": "node test/performance/benchmark/index.js | tee .benchmark-results.txt",
+    "test:bench": "mocha 'test/node/**/*.bench.ts' | grep 'ops/sec' | tee test/node/.benchmark-results.txt",
+    "test:bench:browser": "karma start karma.bench.js --single-run",
     "tdd": "npm run tdd:node",
     "tdd:node": "npm run test -- --watch-extensions ts --watch",
     "tdd:browser": "karma start",
@@ -64,6 +65,7 @@
   },
   "devDependencies": {
     "@opentelemetry/api": ">=1.3.0 <1.10.0",
+    "@types/benchmark": "2.1.5",
     "@types/mocha": "10.0.10",
     "@types/node": "18.19.130",
     "@types/sinon": "17.0.4",

packages/opentelemetry-sdk-trace-base/src/platform/browser/RandomIdGenerator.ts

@@ -16,36 +16,56 @@
 
 import { IdGenerator } from '../../IdGenerator';
 
-const SPAN_ID_BYTES = 8;
 const TRACE_ID_BYTES = 16;
+const SPAN_ID_BYTES = 8;
+
+const TRACE_BUFFER = new Uint8Array(TRACE_ID_BYTES);
+const SPAN_BUFFER = new Uint8Array(SPAN_ID_BYTES);
+
+// Byte-to-hex lookup is faster than toString(16) in browsers
+const HEX: string[] = Array.from({ length: 256 }, (_, i) =>
+  i.toString(16).padStart(2, '0')
+);
+
+/**
+ * Fills buffer with random bytes, ensuring at least one is non-zero
+ * per W3C Trace Context spec.
+ */
+function randomFill(buf: Uint8Array): void {
+  for (let i = 0; i < buf.length; i++) {
+    buf[i] = (Math.random() * 256) >>> 0;
+  }
+  // Ensure non-zero
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] > 0) return;
+  }
+  buf[buf.length - 1] = 1;
+}
+
+function toHex(buf: Uint8Array): string {
+  let hex = '';
+  for (let i = 0; i < buf.length; i++) {
+    hex += HEX[buf[i]];
+  }
+  return hex;
+}
 
 export class RandomIdGenerator implements IdGenerator {
   /**
    * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
    * characters corresponding to 128 bits.
    */
-  generateTraceId = getIdGenerator(TRACE_ID_BYTES);
+  generateTraceId(): string {
+    randomFill(TRACE_BUFFER);
+    return toHex(TRACE_BUFFER);
+  }
 
   /**
    * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
    * characters corresponding to 64 bits.
    */
-  generateSpanId = getIdGenerator(SPAN_ID_BYTES);
-}
-
-const SHARED_CHAR_CODES_ARRAY = Array(32);
-function getIdGenerator(bytes: number): () => string {
-  return function generateId() {
-    for (let i = 0; i < bytes * 2; i++) {
-      SHARED_CHAR_CODES_ARRAY[i] = Math.floor(Math.random() * 16) + 48;
-      // valid hex characters in the range 48-57 and 97-102
-      if (SHARED_CHAR_CODES_ARRAY[i] >= 58) {
-        SHARED_CHAR_CODES_ARRAY[i] += 39;
-      }
-    }
-    return String.fromCharCode.apply(
-      null,
-      SHARED_CHAR_CODES_ARRAY.slice(0, bytes * 2)
-    );
-  };
+  generateSpanId(): string {
+    randomFill(SPAN_BUFFER);
+    return toHex(SPAN_BUFFER);
+  }
 }

packages/opentelemetry-sdk-trace-base/test/browser/RandomIdGenerator.bench.ts

@@ -0,0 +1,46 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as Benchmark from 'benchmark';
+import { RandomIdGenerator } from '../../src/platform';
+
+const idGenerator = new RandomIdGenerator();
+
+describe('RandomIdGenerator benchmark (browser)', function () {
+  this.timeout(60000);
+
+  it('generateTraceId (browser)', done => {
+    const suite = new Benchmark.Suite();
+    suite
+      .add('generateTraceId (browser)', () => idGenerator.generateTraceId())
+      .on('cycle', (event: Benchmark.Event) =>
+        console.log(String(event.target))
+      )
+      .on('complete', () => done())
+      .run({ async: true });
+  });
+
+  it('generateSpanId (browser)', done => {
+    const suite = new Benchmark.Suite();
+    suite
+      .add('generateSpanId (browser)', () => idGenerator.generateSpanId())
+      .on('cycle', (event: Benchmark.Event) =>
+        console.log(String(event.target))
+      )
+      .on('complete', () => done())
+      .run({ async: true });
+  });
+});

packages/opentelemetry-sdk-trace-base/test/browser/Span.bench.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as Benchmark from 'benchmark';
+import { BasicTracerProvider } from '../../src';
+
+const tracerProvider = new BasicTracerProvider();
+const tracer = tracerProvider.getTracer('test');
+
+describe('Span benchmark (browser)', function () {
+  this.timeout(60000);
+
+  it('create spans (10 attributes) (browser)', done => {
+    const suite = new Benchmark.Suite();
+    suite
+      .add('create spans (10 attributes) (browser)', () => {
+        const span = tracer.startSpan('span');
+        span.setAttribute('aaaaaaaaaaaaaaaaaaaa', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('bbbbbbbbbbbbbbbbbbbb', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('cccccccccccccccccccc', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('dddddddddddddddddddd', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('eeeeeeeeeeeeeeeeeeee', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('ffffffffffffffffffff', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('gggggggggggggggggggg', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('hhhhhhhhhhhhhhhhhhhh', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('iiiiiiiiiiiiiiiiiiii', 'aaaaaaaaaaaaaaaaaaaa');
+        span.setAttribute('jjjjjjjjjjjjjjjjjjjj', 'aaaaaaaaaaaaaaaaaaaa');
+        span.end();
+      })
+      .on('cycle', (event: Benchmark.Event) =>
+        console.log(String(event.target))
+      )
+      .on('complete', () => done())
+      .run({ async: true });
+  });
+});

packages/opentelemetry-sdk-trace-base/test/performance/benchmark/span.js → packages/opentelemetry-sdk-trace-base/test/browser/export/BatchSpanProcessor.bench.ts

@@ -14,19 +14,38 @@
  * limitations under the License.
  */
 
-const Benchmark = require('benchmark');
-const { BasicTracerProvider } = require('../../../build/src');
+import * as Benchmark from 'benchmark';
+import {
+  BasicTracerProvider,
+  BatchSpanProcessor,
+  SpanExporter,
+  ReadableSpan,
+} from '../../../src';
+import { ExportResultCode, ExportResult } from '@opentelemetry/core';
 
-const tracerProvider = new BasicTracerProvider();
-const tracer = tracerProvider.getTracer('test')
+class NoopExporter implements SpanExporter {
+  export(
+    spans: ReadableSpan[],
+    resultCallback: (result: ExportResult) => void
+  ): void {
+    setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+  }
 
-const suite = new Benchmark.Suite();
+  shutdown(): Promise<void> {
+    return this.forceFlush();
+  }
 
-suite.on('cycle', event => {
-  console.log(String(event.target));
+  forceFlush(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+const tracerProvider = new BasicTracerProvider({
+  spanProcessors: [new BatchSpanProcessor(new NoopExporter())],
 });
+const tracer = tracerProvider.getTracer('test');
 
-suite.add('create spans (10 attributes)', function() {
+function createSpan(): void {
   const span = tracer.startSpan('span');
   span.setAttribute('aaaaaaaaaaaaaaaaaaaa', 'aaaaaaaaaaaaaaaaaaaa');
   span.setAttribute('bbbbbbbbbbbbbbbbbbbb', 'aaaaaaaaaaaaaaaaaaaa');
@@ -39,6 +58,21 @@ suite.add('create spans (10 attributes)', function() {
   span.setAttribute('iiiiiiiiiiiiiiiiiiii', 'aaaaaaaaaaaaaaaaaaaa');
   span.setAttribute('jjjjjjjjjjjjjjjjjjjj', 'aaaaaaaaaaaaaaaaaaaa');
   span.end();
-});
+}
 
-suite.run();
+describe('BatchSpanProcessor benchmark (browser)', function () {
+  this.timeout(60000);
+
+  it('process span (browser)', done => {
+    const suite = new Benchmark.Suite();
+    suite
+      .add('BatchSpanProcessor process span (browser)', () => {
+        createSpan();
+      })
+      .on('cycle', (event: Benchmark.Event) =>
+        console.log(String(event.target))
+      )
+      .on('complete', () => done())
+      .run({ async: true });
+  });
+});

packages/opentelemetry-sdk-trace-base/test/common/platform/RandomIdGenerator.test.ts → packages/opentelemetry-sdk-trace-base/test/common/RandomIdGenerator.test.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import * as assert from 'assert';
-import { RandomIdGenerator } from '../../../src/platform';
+import { RandomIdGenerator } from '../../src/platform';
 
 const idGenerator = new RandomIdGenerator();
 

packages/opentelemetry-sdk-trace-base/test/common/Sampler.test.ts → packages/opentelemetry-sdk-trace-base/test/common/sampler/Sampler.test.ts

@@ -23,8 +23,8 @@ import {
   SamplingDecision,
   SamplingResult,
   TraceIdRatioBasedSampler,
-} from '../../src';
-import { assertAssignable } from './util';
+} from '../../../src';
+import { assertAssignable } from '../util';
 
 describe('Sampler', () => {
   const samplers = [