@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/server/lib/trace/request-insights.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    clearRequestInsightsForTest: null,
+    getRequestInsightsSnapshot: null,
+    isRequestInsightsEnabled: null,
+    recordRequestInsightFetch: null,
+    recordRequestInsightSpan: null,
+    subscribeRequestInsights: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    clearRequestInsightsForTest: function() {
+        return clearRequestInsightsForTest;
+    },
+    getRequestInsightsSnapshot: function() {
+        return getRequestInsightsSnapshot;
+    },
+    isRequestInsightsEnabled: function() {
+        return _spanstore.isRequestInsightsEnabled;
+    },
+    recordRequestInsightFetch: function() {
+        return recordRequestInsightFetch;
+    },
+    recordRequestInsightSpan: function() {
+        return recordRequestInsightSpan;
+    },
+    subscribeRequestInsights: function() {
+        return subscribeRequestInsights;
+    }
+});
+const _requestinsights = require("../../../shared/lib/request-insights");
+const _spanstore = require("./span-store");
+const MAX_REQUEST_INSIGHTS = 100;
+const REQUEST_INSIGHTS_STORE_KEY = Symbol.for('@next/request-insights-store');
+const CLIENT_COMPONENT_LOADING_SPAN_TYPE = 'NextNodeServer.clientComponentLoading';
+const REDACTED_VALUE = 'redacted';
+const SAFE_SPAN_ATTRIBUTE_KEYS = new Set([
+    'http.method',
+    'http.route',
+    'http.status_code',
+    'http.url',
+    'net.peer.name',
+    'net.peer.port',
+    'next.fetch.cache_reason',
+    'next.fetch.cache_status',
+    'next.fetch.idx',
+    'next.route',
+    'next.rsc',
+    'next.segment',
+    'next.span_category',
+    'next.span_name',
+    'next.span_type'
+]);
+const SENSITIVE_PARAM_NAME_RE = /(?:^|[_-])(?:access[_-]?token|api[_-]?key|auth|authorization|code|cookie|credential|id[_-]?token|jwt|key|password|secret|session|signature|sig|token)(?:$|[_-])/i;
+class InMemoryRequestInsightsStore {
+    recordSpan(span) {
+        var _span_attributes;
+        if (!span.requestId) {
+            return;
+        }
+        const insight = this.getOrCreateRequest({
+            requestId: span.requestId,
+            kind: span.requestInsightKind,
+            htmlRequestId: span.htmlRequestId,
+            route: span.route,
+            url: span.url
+        }, span.startTime ?? span.timestamp);
+        const spanStartTime = span.startTime ?? span.timestamp;
+        insight.htmlRequestId = span.htmlRequestId ?? insight.htmlRequestId;
+        insight.route = insight.route ?? span.route;
+        insight.url = insight.url ?? sanitizeUrl(span.url);
+        this.updateTiming(insight, spanStartTime, span.durationMs, ((_span_attributes = span.attributes) == null ? void 0 : _span_attributes['next.span_type']) === 'BaseServer.handleRequest');
+        insight.status = insight.status === 'error' || span.status === 'error' ? 'error' : span.status === 'ok' ? 'ok' : insight.status;
+        insight.spans.push({
+            name: span.name,
+            startTime: spanStartTime,
+            durationMs: span.durationMs,
+            status: span.status,
+            traceId: span.traceId,
+            spanId: span.spanId,
+            parentSpanId: span.parentSpanId,
+            attributes: sanitizeSpanAttributes(span.attributes),
+            links: sanitizeSpanLinks(span.links),
+            events: sanitizeSpanEvents(span.events),
+            error: span.error
+        });
+        const fetch = getFetchInsight(span);
+        if (fetch) {
+            this.recordFetchForInsight(insight, fetch);
+        }
+        this.notify(insight);
+    }
+    recordFetch(identity, fetch) {
+        if (!identity.requestId) {
+            return;
+        }
+        const fetchStartTime = fetch.startTime ?? getCurrentTimestamp();
+        const insight = this.getOrCreateRequest(identity, fetchStartTime);
+        this.updateTiming(insight, fetchStartTime, fetch.durationMs, false);
+        this.recordFetchForInsight(insight, sanitizeFetchInsight(fetch));
+        this.notify(insight);
+    }
+    getSnapshot() {
+        return {
+            requests: this.requestOrder.map((insightKey)=>this.requests.get(insightKey)).filter((request)=>request !== undefined)
+        };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return ()=>{
+            this.listeners.delete(listener);
+        };
+    }
+    clear() {
+        this.requests.clear();
+        this.requestTimings.clear();
+        this.requestOrder.length = 0;
+    }
+    updateTiming(insight, startTime, durationMs, isRequestSpan) {
+        const insightKey = (0, _requestinsights.getRequestInsightKey)(insight);
+        if (isRequestSpan && durationMs !== undefined) {
+            const requestTiming = {
+                startTime,
+                durationMs
+            };
+            this.requestTimings.set(insightKey, requestTiming);
+            insight.startTime = requestTiming.startTime;
+            insight.durationMs = requestTiming.durationMs;
+            return;
+        }
+        const requestTiming = this.requestTimings.get(insightKey);
+        if (requestTiming) {
+            insight.startTime = requestTiming.startTime;
+            insight.durationMs = requestTiming.durationMs;
+            return;
+        }
+        const endTime = startTime + (durationMs ?? 0);
+        const requestEndTime = insight.startTime + (insight.durationMs ?? 0);
+        insight.startTime = Math.min(insight.startTime, startTime);
+        insight.durationMs = Math.max(requestEndTime, endTime) - insight.startTime;
+    }
+    notify(insight) {
+        for (const listener of this.listeners){
+            listener(insight);
+        }
+    }
+    getOrCreateRequest(identity, startTime) {
+        const requestId = identity.requestId;
+        const insightKey = (0, _requestinsights.getRequestInsightKey)({
+            requestId,
+            kind: identity.kind
+        });
+        let insight = this.requests.get(insightKey);
+        if (!insight) {
+            insight = {
+                requestId,
+                kind: (0, _requestinsights.getRequestInsightKind)(identity),
+                htmlRequestId: identity.htmlRequestId ?? requestId,
+                route: identity.route,
+                url: sanitizeUrl(identity.url),
+                startTime,
+                status: 'pending',
+                spans: [],
+                fetches: []
+            };
+            this.requests.set(insightKey, insight);
+            this.requestOrder.push(insightKey);
+            this.trim();
+        }
+        insight.htmlRequestId = identity.htmlRequestId ?? insight.htmlRequestId;
+        insight.route = insight.route ?? identity.route;
+        insight.url = insight.url ?? sanitizeUrl(identity.url);
+        insight.startTime = Math.min(insight.startTime, startTime);
+        return insight;
+    }
+    recordFetchForInsight(insight, fetch) {
+        if (insight.fetches.some((existingFetch)=>existingFetch.url === fetch.url && (existingFetch.index !== undefined && fetch.index !== undefined ? existingFetch.index === fetch.index : existingFetch.startTime === fetch.startTime))) {
+            return;
+        }
+        insight.fetches.push(sanitizeFetchInsight(fetch));
+    }
+    trim() {
+        while(this.requestOrder.length > MAX_REQUEST_INSIGHTS){
+            const insightKey = this.requestOrder.shift();
+            if (insightKey) {
+                this.requests.delete(insightKey);
+                this.requestTimings.delete(insightKey);
+            }
+        }
+    }
+    constructor(){
+        this.requests = new Map();
+        this.requestTimings = new Map();
+        this.requestOrder = [];
+        this.listeners = new Set();
+    }
+}
+function recordRequestInsightSpan(span) {
+    var _span_attributes;
+    if (((_span_attributes = span.attributes) == null ? void 0 : _span_attributes['next.span_type']) === CLIENT_COMPONENT_LOADING_SPAN_TYPE) {
+        return;
+    }
+    getRequestInsightsStore().recordSpan(span);
+}
+function recordRequestInsightFetch(identity, fetch) {
+    getRequestInsightsStore().recordFetch(identity, fetch);
+}
+function getRequestInsightsSnapshot() {
+    return getRequestInsightsStore().getSnapshot();
+}
+function subscribeRequestInsights(listener) {
+    return getRequestInsightsStore().subscribe(listener);
+}
+function clearRequestInsightsForTest() {
+    getRequestInsightsStore().clear();
+}
+function getRequestInsightsStore() {
+    const globalStore = globalThis;
+    return globalStore[REQUEST_INSIGHTS_STORE_KEY] ??= new InMemoryRequestInsightsStore();
+}
+function getFetchInsight(span) {
+    const attributes = span.attributes;
+    if (!attributes || attributes['next.span_type'] !== 'AppRender.fetch') {
+        return null;
+    }
+    return {
+        url: sanitizeUrl(getStringAttribute(attributes['http.url']) ?? span.url),
+        method: getStringAttribute(attributes['http.method']),
+        statusCode: getNumberAttribute(attributes['http.status_code']),
+        startTime: span.startTime ?? span.timestamp,
+        durationMs: span.durationMs,
+        cacheStatus: getStringAttribute(attributes['next.fetch.cache_status']),
+        cacheReason: getStringAttribute(attributes['next.fetch.cache_reason']),
+        index: getNumberAttribute(attributes['next.fetch.idx'])
+    };
+}
+function sanitizeFetchInsight(fetch) {
+    return {
+        ...fetch,
+        url: sanitizeUrl(fetch.url)
+    };
+}
+function getCurrentTimestamp() {
+    return performance.timeOrigin + performance.now();
+}
+function sanitizeSpanAttributes(attributes) {
+    if (!attributes) {
+        return undefined;
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(attributes)){
+        if (!SAFE_SPAN_ATTRIBUTE_KEYS.has(key)) {
+            continue;
+        }
+        sanitized[key] = key === 'http.url' ? sanitizeUrlAttribute(value) : value;
+    }
+    return Object.keys(sanitized).length > 0 ? sanitized : undefined;
+}
+function sanitizeSpanEvents(events) {
+    return events == null ? void 0 : events.map((event)=>({
+            ...event,
+            attributes: sanitizeSpanAttributes(event.attributes)
+        }));
+}
+function sanitizeSpanLinks(links) {
+    return links == null ? void 0 : links.map((link)=>({
+            ...link,
+            attributes: sanitizeSpanAttributes(link.attributes)
+        }));
+}
+function sanitizeUrlAttribute(value) {
+    return typeof value === 'string' ? sanitizeUrl(value) ?? '' : value;
+}
+function sanitizeUrl(value) {
+    if (!value) {
+        return value;
+    }
+    const isRelativeUrl = value.startsWith('/');
+    try {
+        const url = isRelativeUrl ? new URL(value, 'http://n') : new URL(value);
+        url.username = '';
+        url.password = '';
+        for (const name of Array.from(url.searchParams.keys())){
+            if (SENSITIVE_PARAM_NAME_RE.test(name)) {
+                url.searchParams.set(name, REDACTED_VALUE);
+            }
+        }
+        return isRelativeUrl ? `${url.pathname}${url.search}${url.hash}` : url.href;
+    } catch  {
+        return value;
+    }
+}
+function getStringAttribute(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function getNumberAttribute(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+
+//# sourceMappingURL=request-insights.js.map

package/dist/node_modules/next/dist/server/lib/trace/span-store.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isLocalSpanRecordingEnabled: null,
+    isRequestInsightsEnabled: null,
+    recordSpan: null,
+    setSpanRecorderForTest: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isLocalSpanRecordingEnabled: function() {
+        return isLocalSpanRecordingEnabled;
+    },
+    isRequestInsightsEnabled: function() {
+        return isRequestInsightsEnabled;
+    },
+    recordSpan: function() {
+        return recordSpan;
+    },
+    setSpanRecorderForTest: function() {
+        return setSpanRecorderForTest;
+    }
+});
+let spanRecorderForTest;
+function recordSpan(record) {
+    if (!isLocalSpanRecordingEnabled()) {
+        return;
+    }
+    const spanRecord = {
+        timestamp: getCurrentTimestamp(),
+        ...record
+    };
+    spanRecorderForTest == null ? void 0 : spanRecorderForTest(spanRecord);
+    if (isRequestInsightsEnabled() && spanRecord.requestId) {
+        const { recordRequestInsightSpan } = require('./request-insights');
+        recordRequestInsightSpan(spanRecord);
+    }
+}
+function setSpanRecorderForTest(recorder) {
+    spanRecorderForTest = recorder;
+}
+function isLocalSpanRecordingEnabled() {
+    if (!process.env.__NEXT_DEV_SERVER) {
+        return false;
+    }
+    return spanRecorderForTest !== undefined || isRequestInsightsEnabled();
+}
+function isRequestInsightsEnabled() {
+    if (!process.env.__NEXT_DEV_SERVER) {
+        return false;
+    }
+    const value = process.env.__NEXT_REQUEST_INSIGHTS;
+    return isEnabledEnvValue(value);
+}
+function isEnabledEnvValue(value) {
+    return value === '1' || value === 'true' || value === true;
+}
+function getCurrentTimestamp() {
+    return performance.timeOrigin + performance.now();
+}
+
+//# sourceMappingURL=span-store.js.map

package/dist/node_modules/next/dist/server/lib/trace/tracer.js

@@ -35,7 +35,15 @@ _export(exports, {
 const _constants = require("./constants");
 const _isthenable = require("../../../shared/lib/is-thenable");
 const NEXT_OTEL_PERFORMANCE_PREFIX = process.env.NEXT_OTEL_PERFORMANCE_PREFIX;
+const LOCAL_SPAN_RECORDER_KEY = Symbol.for('@next/local-span-recorder');
 let api;
+function getLocalSpanRecorder() {
+    if (process.env.__NEXT_DEV_SERVER) {
+        return globalThis[LOCAL_SPAN_RECORDER_KEY];
+    } else {
+        return undefined;
+    }
+}
 // we want to allow users to use their own version of @opentelemetry/api if they
 // want to, so we try to require it first, and if it fails we fall back to the
 // version that is bundled with Next.js
@@ -97,6 +105,18 @@ class NextTracerImpl {
    */ getTracerInstance() {
         return trace.getTracer('next.js', '0.0.1');
     }
+    isOpenTelemetryEnabled() {
+        var _tracerProvider_getDelegate_constructor, _tracerProvider_getDelegate;
+        const activeSpan = trace.getSpan(context.active());
+        if (activeSpan == null ? void 0 : activeSpan.isRecording()) {
+            return true;
+        }
+        const tracerProvider = trace.getTracerProvider();
+        if (!('getDelegate' in tracerProvider)) {
+            return true;
+        }
+        return (tracerProvider.getDelegate == null ? void 0 : (_tracerProvider_getDelegate = tracerProvider.getDelegate.call(tracerProvider)) == null ? void 0 : (_tracerProvider_getDelegate_constructor = _tracerProvider_getDelegate.constructor) == null ? void 0 : _tracerProvider_getDelegate_constructor.name) !== 'NoopTracerProvider';
+    }
     getContext() {
         return context;
     }
@@ -107,10 +127,33 @@ class NextTracerImpl {
         return entries;
     }
     getActiveScopeSpan() {
-        return trace.getSpan(context == null ? void 0 : context.active());
+        const localSpanRecorder = getLocalSpanRecorder();
+        const activeLocalSpan = localSpanRecorder == null ? void 0 : localSpanRecorder.getActiveLocalSpan();
+        if (activeLocalSpan && (localSpanRecorder == null ? void 0 : localSpanRecorder.isOpenTelemetryIsolatedSpan(activeLocalSpan))) {
+            return activeLocalSpan;
+        }
+        const activeSpan = trace.getSpan(context.active());
+        if (activeSpan || !process.env.__NEXT_DEV_SERVER) {
+            return activeSpan;
+        }
+        return activeLocalSpan;
+    }
+    /**
+   * Run `fn` with the active span cleared, so spans created inside become new
+   * roots (or parent to incoming propagated context). Used for in-process
+   * Node.js middleware so its span is a sibling of the request span, matching
+   * edge middleware which runs in a detached sandbox.
+   */ runWithDetachedContext(fn) {
+        if (!NEXT_OTEL_PERFORMANCE_PREFIX && !this.isOpenTelemetryEnabled()) {
+            return fn();
+        }
+        return context.with(ROOT_CONTEXT, fn);
     }
     withPropagatedContext(carrier, fn, getter, force = false) {
         const activeContext = context.active();
+        if (!NEXT_OTEL_PERFORMANCE_PREFIX && !this.isOpenTelemetryEnabled() && !trace.getSpanContext(activeContext)) {
+            return fn();
+        }
         if (force) {
             const remoteContext = propagation.extract(ROOT_CONTEXT, carrier, getter);
             if (trace.getSpanContext(remoteContext)) {
@@ -130,6 +173,12 @@ class NextTracerImpl {
     }
     trace(...args) {
         const [type, fnOrOptions, fnOrEmpty] = args;
+        const tracingEnabled = Boolean(NEXT_OTEL_PERFORMANCE_PREFIX) || this.isOpenTelemetryEnabled();
+        const localSpanRecorder = getLocalSpanRecorder();
+        const localSpanRecordingEnabled = (localSpanRecorder == null ? void 0 : localSpanRecorder.isLocalSpanRecordingEnabled()) ?? false;
+        if (!tracingEnabled && !localSpanRecordingEnabled) {
+            return typeof fnOrOptions === 'function' ? fnOrOptions() : fnOrEmpty();
+        }
         // coerce options form overload
         const { fn, options } = typeof fnOrOptions === 'function' ? {
             fn: fnOrOptions,
@@ -141,11 +190,15 @@ class NextTracerImpl {
             }
         };
         const spanName = options.spanName ?? type;
-        if (!_constants.NextVanillaSpanAllowlist.has(type) && process.env.NEXT_OTEL_VERBOSE !== '1' || options.hideSpan) {
+        const parentSpan = options.parentSpan ?? this.getActiveScopeSpan();
+        const isolatedParentSpan = parentSpan && (localSpanRecorder == null ? void 0 : localSpanRecorder.isOpenTelemetryIsolatedSpan(parentSpan)) ? parentSpan : undefined;
+        const shouldDelegateSpan = !isolatedParentSpan && (_constants.NextVanillaSpanAllowlist.has(type) || process.env.NEXT_OTEL_VERBOSE === '1');
+        const shouldTraceSpan = shouldDelegateSpan || ((localSpanRecorder == null ? void 0 : localSpanRecorder.isRequestInsightsEnabled()) ?? false);
+        if (!shouldTraceSpan || options.hideSpan) {
             return fn();
         }
         // Trying to get active scoped span to assign parent. If option specifies parent span manually, will try to use it.
-        let spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan());
+        let spanContext = isolatedParentSpan ? context.active() : this.getSpanContext(parentSpan);
         if (!spanContext) {
             spanContext = (context == null ? void 0 : context.active()) ?? ROOT_CONTEXT;
         }
@@ -157,11 +210,12 @@ class NextTracerImpl {
         const isRootSpan = typeof existingRootSpanId !== 'number' || !rootSpanAttributesStore.has(existingRootSpanId);
         const spanId = getSpanId();
         options.attributes = {
+            'next.span_category': 'nextjs',
             'next.span_name': spanName,
             'next.span_type': type,
             ...options.attributes
         };
-        return context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.getTracerInstance().startActiveSpan(spanName, options, (span)=>{
+        return context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.runWithActiveSpan(spanName, options, spanContext, tracingEnabled && shouldDelegateSpan, localSpanRecordingEnabled, isolatedParentSpan, (span)=>{
                 let startTime;
                 if (NEXT_OTEL_PERFORMANCE_PREFIX && type && _constants.LogSpanAllowList.has(type)) {
                     startTime = 'performance' in globalThis && 'measure' in performance ? globalThis.performance.now() : undefined;
@@ -183,7 +237,13 @@ class NextTracerImpl {
                 }
                 if (fn.length > 1) {
                     try {
-                        return fn(span, (err)=>closeSpanWithError(span, err));
+                        return fn(span, (err)=>{
+                            if (err) {
+                                closeSpanWithError(span, err);
+                            } else {
+                                span.end();
+                            }
+                        });
                     } catch (err) {
                         closeSpanWithError(span, err);
                         throw err;
@@ -216,6 +276,29 @@ class NextTracerImpl {
                 }
             }));
     }
+    runWithActiveSpan(spanName, options, parentContext, tracingEnabled, localSpanRecordingEnabled, isolatedParentSpan, fn) {
+        if (tracingEnabled) {
+            return this.getTracerInstance().startActiveSpan(spanName, options, (span)=>fn(localSpanRecordingEnabled ? this.createLocalRecordingSpan(spanName, options, parentContext, span, isolatedParentSpan) : span));
+        }
+        const span = this.createLocalRecordingSpan(spanName, options, parentContext, undefined, isolatedParentSpan);
+        const localSpanRecorder = getLocalSpanRecorder();
+        return localSpanRecorder.withLocalSpan(span, ()=>localSpanRecorder.isOpenTelemetryIsolatedSpan(span) ? fn(span) : context.with(trace.setSpan(context.active(), span), fn, undefined, span));
+    }
+    createLocalRecordingSpan(name, options, parentContext, delegateSpan, isolatedParentSpan) {
+        const parentSpanContext = (isolatedParentSpan == null ? void 0 : isolatedParentSpan.spanContext()) ?? trace.getSpanContext(parentContext);
+        const delegateSpanContext = delegateSpan == null ? void 0 : delegateSpan.spanContext();
+        return getLocalSpanRecorder().createLocalSpan({
+            name,
+            attributes: options.attributes,
+            links: options.links,
+            startTime: options.startTime,
+            delegateSpan,
+            traceId: (delegateSpanContext == null ? void 0 : delegateSpanContext.traceId) ?? (parentSpanContext == null ? void 0 : parentSpanContext.traceId),
+            spanId: delegateSpanContext == null ? void 0 : delegateSpanContext.spanId,
+            parentSpanId: parentSpanContext == null ? void 0 : parentSpanContext.spanId,
+            isolateOpenTelemetry: isolatedParentSpan !== undefined
+        });
+    }
     wrap(...args) {
         const tracer = this;
         const [name, options, fn] = args.length === 3 ? args : [
@@ -223,7 +306,7 @@ class NextTracerImpl {
             {},
             args[1]
         ];
-        if (!_constants.NextVanillaSpanAllowlist.has(name) && process.env.NEXT_OTEL_VERBOSE !== '1') {
+        if (!_constants.NextVanillaSpanAllowlist.has(name) && process.env.NEXT_OTEL_VERBOSE !== '1' && !process.env.__NEXT_DEV_SERVER) {
             return fn;
         }
         return function() {
@@ -248,9 +331,28 @@ class NextTracerImpl {
         };
     }
     startSpan(...args) {
-        const [type, options] = args;
-        const spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan());
-        return this.getTracerInstance().startSpan(type, options, spanContext);
+        const [type, passedOptions] = args;
+        const options = passedOptions ? {
+            ...passedOptions,
+            attributes: {
+                'next.span_category': 'nextjs',
+                ...passedOptions.attributes
+            }
+        } : {
+            attributes: {
+                'next.span_category': 'nextjs'
+            }
+        };
+        const localSpanRecorder = getLocalSpanRecorder();
+        const parentSpan = options.parentSpan ?? this.getActiveScopeSpan();
+        const isolatedParentSpan = parentSpan && (localSpanRecorder == null ? void 0 : localSpanRecorder.isOpenTelemetryIsolatedSpan(parentSpan)) ? parentSpan : undefined;
+        const parentContext = (isolatedParentSpan ? undefined : this.getSpanContext(parentSpan)) ?? context.active();
+        const localSpanRecordingEnabled = (localSpanRecorder == null ? void 0 : localSpanRecorder.isLocalSpanRecordingEnabled()) ?? false;
+        if (!localSpanRecordingEnabled) {
+            return this.getTracerInstance().startSpan(type, options, parentContext);
+        }
+        const delegateSpan = !isolatedParentSpan && this.isOpenTelemetryEnabled() ? this.getTracerInstance().startSpan(type, options, parentContext) : undefined;
+        return this.createLocalRecordingSpan(type, options, parentContext, delegateSpan, isolatedParentSpan);
     }
     getSpanContext(parentSpan) {
         const spanContext = parentSpan ? trace.setSpan(context.active(), parentSpan) : undefined;
@@ -266,10 +368,20 @@ class NextTracerImpl {
         if (attributes && !attributes.has(key)) {
             attributes.set(key, value);
         }
+        if (process.env.__NEXT_DEV_SERVER) {
+            var _getLocalSpanRecorder;
+            const localSpan = (_getLocalSpanRecorder = getLocalSpanRecorder()) == null ? void 0 : _getLocalSpanRecorder.getActiveLocalSpan();
+            if (localSpan) {
+                localSpan.setAttribute(key, value);
+            }
+        }
     }
     withSpan(span, fn) {
-        const spanContext = trace.setSpan(context.active(), span);
-        return context.with(spanContext, fn);
+        const recorder = getLocalSpanRecorder();
+        if (recorder == null ? void 0 : recorder.isLocalRecordingSpan(span)) {
+            return recorder.withLocalSpan(span, ()=>recorder.isOpenTelemetryIsolatedSpan(span) ? fn() : context.with(trace.setSpan(context.active(), span), fn));
+        }
+        return context.with(trace.setSpan(context.active(), span), fn);
     }
 }
 const getTracer = (()=>{

package/dist/node_modules/next/dist/server/lib/utils.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", {
     formatNodeOptions: null,
     getFormattedNodeOptionsWithoutInspect: null,
     getMaxOldSpaceSize: null,
+    getMemoryRestartStats: null,
     getNodeDebugType: null,
     getNodeOptionsArgs: null,
     getParsedDebugAddress: null,
@@ -39,6 +40,9 @@ _export(exports, {
     getMaxOldSpaceSize: function() {
         return getMaxOldSpaceSize;
     },
+    getMemoryRestartStats: function() {
+        return getMemoryRestartStats;
+    },
     getNodeDebugType: function() {
         return getNodeDebugType;
     },
@@ -258,6 +262,16 @@ function parseValidPositiveInteger(value) {
     return parsedValue;
 }
 const RESTART_EXIT_CODE = 77;
+function getMemoryRestartStats(isDev, devMemoryThresholdRestart, getHeapStatistics) {
+    if (!isDev || !devMemoryThresholdRestart) {
+        return undefined;
+    }
+    const heapStatistics = getHeapStatistics();
+    if (heapStatistics.used_heap_size > 0.8 * heapStatistics.heap_size_limit) {
+        return heapStatistics;
+    }
+    return undefined;
+}
 function getNodeDebugType(nodeOptions) {
     if (nodeOptions.inspect) {
         return 'inspect';

package/dist/node_modules/next/dist/server/load-components.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     evalManifestWithRetries: null,
+    loadClientReferenceManifestForPage: null,
     loadComponents: null,
     loadManifestWithRetries: null,
     tryLoadManifestWithRetries: null
@@ -18,6 +19,9 @@ _export(exports, {
     evalManifestWithRetries: function() {
         return evalManifestWithRetries;
     },
+    loadClientReferenceManifestForPage: function() {
+        return loadClientReferenceManifestForPage;
+    },
     loadComponents: function() {
         return loadComponents;
     },
@@ -68,7 +72,9 @@ async function evalManifestWithRetries(manifestPath, attempts = 3) {
         }
     }
 }
-async function tryLoadClientReferenceManifest(manifestPath, entryName, attempts) {
+async function loadClientReferenceManifestForPage(distDir, page, attempts) {
+    const entryName = page.replace(/%5F/g, '_');
+    const manifestPath = (0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', 'app', entryName + '_' + _constants.CLIENT_REFERENCE_MANIFEST + '.js');
     try {
         const context = await evalManifestWithRetries(manifestPath, attempts);
         return context.__RSC_MANIFEST[entryName];
@@ -115,7 +121,7 @@ needsManifestsForLegacyReasons }) {
             tryLoadManifestWithRetries(reactLoadableManifestPath, manifestLoadAttempts),
             // This manifest will only exist in Pages dir && Production && Webpack.
             isAppPath || process.env.TURBOPACK ? undefined : loadManifestWithRetries((0, _path.join)(/* turbopackIgnore: true */ distDir, `${_constants.DYNAMIC_CSS_MANIFEST}.json`), manifestLoadAttempts).catch(()=>undefined),
-            isAppPath && hasClientManifest ? tryLoadClientReferenceManifest((0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', 'app', page.replace(/%5F/g, '_') + '_' + _constants.CLIENT_REFERENCE_MANIFEST + '.js'), page.replace(/%5F/g, '_'), manifestLoadAttempts) : undefined,
+            isAppPath && hasClientManifest ? loadClientReferenceManifestForPage(distDir, page, manifestLoadAttempts) : undefined,
             isAppPath ? loadManifestWithRetries((0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', _constants.SERVER_REFERENCE_MANIFEST + '.json'), manifestLoadAttempts).catch(()=>null) : null,
             sriEnabled ? loadManifestWithRetries((0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', _constants.SUBRESOURCE_INTEGRITY_MANIFEST + '.json')).catch(()=>undefined) : undefined
         ]);