@salesforce/pwa-kit-react-sdk 3.12.0 → 3.13.0-nightly-20250909080205

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## v3.13.0-nightly-20250909080205 (Sep 09, 2025)
+## v3.13.0-dev (Sep 04, 2025)
+- Opentelemetry integration for SSR tracing [#3133](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/3133)
+
 ## v3.12.0 (Sep 04, 2025)
 - Add support for environment level base paths on /mobify routes [#2892](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/2892)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/pwa-kit-react-sdk",
-  "version": "3.12.0",
+  "version": "3.13.0-nightly-20250909080205",
   "description": "A library that supports the isomorphic React rendering pipeline for Commerce Cloud Managed Runtime apps",
   "homepage": "https://github.com/SalesforceCommerceCloud/pwa-kit/tree/develop/packages/pwa-kit-react-sdk#readme",
   "bugs": {
@@ -37,7 +37,13 @@
     "@loadable/babel-plugin": "^5.15.3",
     "@loadable/server": "^5.15.3",
     "@loadable/webpack-plugin": "^5.15.2",
-    "@salesforce/pwa-kit-runtime": "3.12.0",
+    "@opentelemetry/api": "^1.4.1",
+    "@opentelemetry/core": "^1.15.1",
+    "@opentelemetry/propagator-b3": "^1.15.1",
+    "@opentelemetry/resources": "^1.15.1",
+    "@opentelemetry/sdk-trace-base": "^1.15.1",
+    "@opentelemetry/sdk-trace-node": "^1.15.1",
+    "@salesforce/pwa-kit-runtime": "3.13.0-nightly-20250909080205",
     "@tanstack/react-query": "^4.28.0",
     "cross-env": "^5.2.1",
     "event-emitter": "^0.3.5",
@@ -50,11 +56,11 @@
   },
   "devDependencies": {
     "@loadable/component": "^5.15.3",
-    "@salesforce/pwa-kit-dev": "3.12.0",
+    "@salesforce/pwa-kit-dev": "3.13.0-nightly-20250909080205",
     "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/react": "^14.0.0",
     "@testing-library/user-event": "14.4.3",
-    "internal-lib-build": "3.12.0",
+    "internal-lib-build": "3.13.0-nightly-20250909080205",
     "node-html-parser": "^3.3.6",
     "nodemon": "^2.0.22",
     "react": "^18.2.0",
@@ -79,5 +85,5 @@
   "publishConfig": {
     "directory": "dist"
   },
-  "gitHead": "8fe2805d21aec09eb9ae86cce1e4ceeb828f61f1"
+  "gitHead": "6f1395801a36b95520095770165cb0124a1928fe"
 }

package/ssr/server/opentelemetry-server.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tracePerformance = exports.shutdownServerTracing = exports.isServerTracingInitialized = exports.initializeServerTracing = exports.getServerTracingProvider = void 0;
+var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
+var _sdkTraceBase = require("@opentelemetry/sdk-trace-base");
+var _propagatorB = require("@opentelemetry/propagator-b3");
+var _resources = require("@opentelemetry/resources");
+var _api = require("@opentelemetry/api");
+var _loggerInstance = _interopRequireDefault(require("../../utils/logger-instance"));
+var _opentelemetryConfig = require("../../utils/opentelemetry-config");
+var _opentelemetry = require("../../utils/opentelemetry");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; } /*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+let provider = null;
+
+/**
+ * Initialize OpenTelemetry tracing for server-side rendering
+ * @param {Object} options
+ * @param {string} [options.serviceName]
+ * @param {string} [options.serviceVersion]
+ * @param {boolean} [options.enabled]
+ * @returns {NodeTracerProvider|null}
+ */
+const initializeServerTracing = (options = {}) => {
+  const {
+    serviceName = options.serviceName || (0, _opentelemetryConfig.getServiceName)(),
+    serviceVersion,
+    enabled = (0, _opentelemetryConfig.getOTELConfig)().enabled
+  } = options;
+  // If tracing is disabled, return null without initializing
+  if (!enabled) {
+    return null;
+  }
+  try {
+    // Build resource attributes
+    const resourceAttributes = {
+      'service.name': serviceName
+    };
+
+    // Add service version if provided
+    if (serviceVersion) {
+      resourceAttributes['service.version'] = serviceVersion;
+    }
+
+    // Initialize the tracer provider
+    provider = new _sdkTraceNode.NodeTracerProvider({
+      resource: new _resources.Resource(resourceAttributes),
+      spanProcessor: new _sdkTraceBase.SimpleSpanProcessor()
+    });
+
+    // Add B3 propagator
+    _api.propagation.setGlobalPropagator(new _propagatorB.B3Propagator());
+    provider.register();
+    return provider;
+  } catch (error) {
+    // Log errors from OpenTelemetry initialization
+    _loggerInstance.default.error('Failed to initialize OpenTelemetry provider', {
+      namespace: 'opentelemetry-server.initializeServerTracing',
+      additionalProperties: {
+        error: error.message
+      }
+    });
+    return null;
+  }
+};
+
+/**
+ * Shutdown OpenTelemetry tracing and clean up resources
+ * @returns {Promise<void>}
+ */
+exports.initializeServerTracing = initializeServerTracing;
+const shutdownServerTracing = exports.shutdownServerTracing = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* () {
+    if (provider) {
+      try {
+        yield provider.shutdown();
+        provider = null; // Clean up after successful shutdown
+      } catch (error) {
+        _loggerInstance.default.warn('Failed to shutdown OpenTelemetry provider', {
+          namespace: 'opentelemetry-server.shutdownServerTracing',
+          additionalProperties: {
+            error: error.message
+          }
+        });
+      }
+    }
+  });
+  return function shutdownServerTracing() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+/**
+ * Get the current OpenTelemetry provider instance
+ * @returns {NodeTracerProvider|null} The current provider or null if not initialized
+ */
+const getServerTracingProvider = () => {
+  return provider;
+};
+
+/**
+ * Check if OpenTelemetry tracing is currently initialized
+ * @returns {boolean} True if tracing is initialized, false otherwise
+ */
+exports.getServerTracingProvider = getServerTracingProvider;
+const isServerTracingInitialized = () => {
+  return provider !== null;
+};
+
+/**
+ * Creates a span for performance measurement
+ * @param {string} name - The name of the performance span
+ * @param {Function} fn - The function to measure
+ * @param {Object} res - The response object (optional)
+ * @returns {Promise<any>} The result of the function
+ */
+exports.isServerTracingInitialized = isServerTracingInitialized;
+const tracePerformance = exports.tracePerformance = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(function* (name, fn, res = null, req = null) {
+    // Check if OpenTelemetry is properly configured
+    const otelConfig = (0, _opentelemetryConfig.getOTELConfig)();
+    let rootSpan = null;
+    let ctx = null;
+    const includeServerTimingHeader = '__server_timing' in req.query;
+    const shouldTrackPerformance = includeServerTimingHeader || process.env.SERVER_TIMING;
+    if (otelConfig.enabled && shouldTrackPerformance) {
+      // Initialize server tracing if needed for this request
+      if (shouldTrackPerformance && !isServerTracingInitialized()) {
+        initializeServerTracing();
+      }
+      const tracer = _api.trace.getTracer((0, _opentelemetryConfig.getServiceName)());
+      // Create the root span
+      rootSpan = tracer.startSpan(name, {
+        attributes: {
+          'service.name': (0, _opentelemetryConfig.getServiceName)()
+        }
+      });
+
+      // Create a new context with the root span
+      ctx = _api.trace.setSpan(_api.context.active(), rootSpan);
+
+      // Inject B3 headers into response if available
+      if (res && (0, _opentelemetryConfig.getOTELConfig)().enabled && shouldTrackPerformance) {
+        res.setHeader('x-b3-traceid', rootSpan.spanContext().traceId);
+        res.setHeader('x-b3-spanid', rootSpan.spanContext().spanId);
+        res.setHeader('x-b3-sampled', '1');
+      }
+    }
+    try {
+      // Run the function within the context of the root span (if ctx exists)
+      const result = ctx ? yield _api.context.with(ctx, /*#__PURE__*/_asyncToGenerator(function* () {
+        try {
+          return yield fn();
+        } catch (error) {
+          rootSpan.setStatus({
+            code: _api.SpanStatusCode.ERROR,
+            message: error.message
+          });
+          throw error;
+        }
+      })) : yield fn();
+      if (otelConfig.enabled && shouldTrackPerformance) {
+        rootSpan.end();
+        (0, _opentelemetry.logSpanData)(rootSpan, 'end', res);
+      }
+      return result;
+    } catch (error) {
+      if (otelConfig.enabled && shouldTrackPerformance) {
+        rootSpan.end();
+        (0, _opentelemetry.logSpanData)(rootSpan, 'end', res);
+      }
+      throw error;
+    }
+  });
+  return function tracePerformance(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();