main repo

node_modules/next/dist/server/lib/trace/constants.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Contains predefined constants for the trace span name in next/server.
+ *
+ * Currently, next/server/tracer is internal implementation only for tracking
+ * next.js's implementation only with known span names defined here.
+ **/
+declare enum BaseServerSpan {
+    handleRequest = "BaseServer.handleRequest",
+    run = "BaseServer.run",
+    pipe = "BaseServer.pipe",
+    getStaticHTML = "BaseServer.getStaticHTML",
+    render = "BaseServer.render",
+    renderToResponseWithComponents = "BaseServer.renderToResponseWithComponents",
+    renderToResponse = "BaseServer.renderToResponse",
+    renderToHTML = "BaseServer.renderToHTML",
+    renderError = "BaseServer.renderError",
+    renderErrorToResponse = "BaseServer.renderErrorToResponse",
+    renderErrorToHTML = "BaseServer.renderErrorToHTML",
+    render404 = "BaseServer.render404"
+}
+declare enum LoadComponentsSpan {
+    loadDefaultErrorComponents = "LoadComponents.loadDefaultErrorComponents",
+    loadComponents = "LoadComponents.loadComponents"
+}
+declare enum NextServerSpan {
+    getRequestHandler = "NextServer.getRequestHandler",
+    getServer = "NextServer.getServer",
+    getServerRequestHandler = "NextServer.getServerRequestHandler",
+    createServer = "createServer.createServer"
+}
+declare enum NextNodeServerSpan {
+    compression = "NextNodeServer.compression",
+    getBuildId = "NextNodeServer.getBuildId",
+    generateStaticRoutes = "NextNodeServer.generateStaticRoutes",
+    generateFsStaticRoutes = "NextNodeServer.generateFsStaticRoutes",
+    generatePublicRoutes = "NextNodeServer.generatePublicRoutes",
+    generateImageRoutes = "NextNodeServer.generateImageRoutes.route",
+    sendRenderResult = "NextNodeServer.sendRenderResult",
+    proxyRequest = "NextNodeServer.proxyRequest",
+    runApi = "NextNodeServer.runApi",
+    render = "NextNodeServer.render",
+    renderHTML = "NextNodeServer.renderHTML",
+    imageOptimizer = "NextNodeServer.imageOptimizer",
+    getPagePath = "NextNodeServer.getPagePath",
+    getRoutesManifest = "NextNodeServer.getRoutesManifest",
+    findPageComponents = "NextNodeServer.findPageComponents",
+    getFontManifest = "NextNodeServer.getFontManifest",
+    getServerComponentManifest = "NextNodeServer.getServerComponentManifest",
+    getRequestHandler = "NextNodeServer.getRequestHandler",
+    renderToHTML = "NextNodeServer.renderToHTML",
+    renderError = "NextNodeServer.renderError",
+    renderErrorToHTML = "NextNodeServer.renderErrorToHTML",
+    render404 = "NextNodeServer.render404",
+    route = "route",
+    onProxyReq = "onProxyReq",
+    apiResolver = "apiResolver",
+    internalFetch = "internalFetch"
+}
+declare enum StartServerSpan {
+    startServer = "startServer.startServer"
+}
+declare enum RenderSpan {
+    getServerSideProps = "Render.getServerSideProps",
+    getStaticProps = "Render.getStaticProps",
+    renderToString = "Render.renderToString",
+    renderDocument = "Render.renderDocument",
+    createBodyResult = "Render.createBodyResult"
+}
+declare enum AppRenderSpan {
+    renderToString = "AppRender.renderToString",
+    renderToReadableStream = "AppRender.renderToReadableStream",
+    getBodyResult = "AppRender.getBodyResult",
+    fetch = "AppRender.fetch"
+}
+declare enum RouterSpan {
+    executeRoute = "Router.executeRoute"
+}
+declare enum NodeSpan {
+    runHandler = "Node.runHandler"
+}
+declare enum AppRouteRouteHandlersSpan {
+    runHandler = "AppRouteRouteHandlers.runHandler"
+}
+declare enum ResolveMetadataSpan {
+    generateMetadata = "ResolveMetadata.generateMetadata"
+}
+type SpanTypes = `${BaseServerSpan}` | `${LoadComponentsSpan}` | `${NextServerSpan}` | `${StartServerSpan}` | `${NextNodeServerSpan}` | `${RenderSpan}` | `${RouterSpan}` | `${AppRenderSpan}` | `${NodeSpan}` | `${AppRouteRouteHandlersSpan}` | `${ResolveMetadataSpan}`;
+export declare const NextVanillaSpanAllowlist: (BaseServerSpan | RenderSpan | AppRenderSpan | NodeSpan | AppRouteRouteHandlersSpan | ResolveMetadataSpan)[];
+export { BaseServerSpan, LoadComponentsSpan, NextServerSpan, NextNodeServerSpan, StartServerSpan, SpanTypes, RenderSpan, RouterSpan, AppRenderSpan, NodeSpan, AppRouteRouteHandlersSpan, ResolveMetadataSpan, };

node_modules/next/dist/server/lib/trace/constants.js

@@ -0,0 +1,173 @@
+/**
+ * Contains predefined constants for the trace span name in next/server.
+ *
+ * Currently, next/server/tracer is internal implementation only for tracking
+ * next.js's implementation only with known span names defined here.
+ **/ // eslint typescript has a bug with TS enums
+/* eslint-disable no-shadow */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NextVanillaSpanAllowlist: null,
+    BaseServerSpan: null,
+    LoadComponentsSpan: null,
+    NextServerSpan: null,
+    NextNodeServerSpan: null,
+    StartServerSpan: null,
+    RenderSpan: null,
+    RouterSpan: null,
+    AppRenderSpan: null,
+    NodeSpan: null,
+    AppRouteRouteHandlersSpan: null,
+    ResolveMetadataSpan: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NextVanillaSpanAllowlist: function() {
+        return NextVanillaSpanAllowlist;
+    },
+    BaseServerSpan: function() {
+        return BaseServerSpan;
+    },
+    LoadComponentsSpan: function() {
+        return LoadComponentsSpan;
+    },
+    NextServerSpan: function() {
+        return NextServerSpan;
+    },
+    NextNodeServerSpan: function() {
+        return NextNodeServerSpan;
+    },
+    StartServerSpan: function() {
+        return StartServerSpan;
+    },
+    RenderSpan: function() {
+        return RenderSpan;
+    },
+    RouterSpan: function() {
+        return RouterSpan;
+    },
+    AppRenderSpan: function() {
+        return AppRenderSpan;
+    },
+    NodeSpan: function() {
+        return NodeSpan;
+    },
+    AppRouteRouteHandlersSpan: function() {
+        return AppRouteRouteHandlersSpan;
+    },
+    ResolveMetadataSpan: function() {
+        return ResolveMetadataSpan;
+    }
+});
+var BaseServerSpan;
+(function(BaseServerSpan) {
+    BaseServerSpan["handleRequest"] = "BaseServer.handleRequest";
+    BaseServerSpan["run"] = "BaseServer.run";
+    BaseServerSpan["pipe"] = "BaseServer.pipe";
+    BaseServerSpan["getStaticHTML"] = "BaseServer.getStaticHTML";
+    BaseServerSpan["render"] = "BaseServer.render";
+    BaseServerSpan["renderToResponseWithComponents"] = "BaseServer.renderToResponseWithComponents";
+    BaseServerSpan["renderToResponse"] = "BaseServer.renderToResponse";
+    BaseServerSpan["renderToHTML"] = "BaseServer.renderToHTML";
+    BaseServerSpan["renderError"] = "BaseServer.renderError";
+    BaseServerSpan["renderErrorToResponse"] = "BaseServer.renderErrorToResponse";
+    BaseServerSpan["renderErrorToHTML"] = "BaseServer.renderErrorToHTML";
+    BaseServerSpan["render404"] = "BaseServer.render404";
+})(BaseServerSpan || (BaseServerSpan = {}));
+var LoadComponentsSpan;
+(function(LoadComponentsSpan) {
+    LoadComponentsSpan["loadDefaultErrorComponents"] = "LoadComponents.loadDefaultErrorComponents";
+    LoadComponentsSpan["loadComponents"] = "LoadComponents.loadComponents";
+})(LoadComponentsSpan || (LoadComponentsSpan = {}));
+var NextServerSpan;
+(function(NextServerSpan) {
+    NextServerSpan["getRequestHandler"] = "NextServer.getRequestHandler";
+    NextServerSpan["getServer"] = "NextServer.getServer";
+    NextServerSpan["getServerRequestHandler"] = "NextServer.getServerRequestHandler";
+    NextServerSpan["createServer"] = "createServer.createServer";
+})(NextServerSpan || (NextServerSpan = {}));
+var NextNodeServerSpan;
+(function(NextNodeServerSpan) {
+    NextNodeServerSpan["compression"] = "NextNodeServer.compression";
+    NextNodeServerSpan["getBuildId"] = "NextNodeServer.getBuildId";
+    NextNodeServerSpan["generateStaticRoutes"] = "NextNodeServer.generateStaticRoutes";
+    NextNodeServerSpan["generateFsStaticRoutes"] = "NextNodeServer.generateFsStaticRoutes";
+    NextNodeServerSpan["generatePublicRoutes"] = "NextNodeServer.generatePublicRoutes";
+    NextNodeServerSpan["generateImageRoutes"] = "NextNodeServer.generateImageRoutes.route";
+    NextNodeServerSpan["sendRenderResult"] = "NextNodeServer.sendRenderResult";
+    NextNodeServerSpan["proxyRequest"] = "NextNodeServer.proxyRequest";
+    NextNodeServerSpan["runApi"] = "NextNodeServer.runApi";
+    NextNodeServerSpan["render"] = "NextNodeServer.render";
+    NextNodeServerSpan["renderHTML"] = "NextNodeServer.renderHTML";
+    NextNodeServerSpan["imageOptimizer"] = "NextNodeServer.imageOptimizer";
+    NextNodeServerSpan["getPagePath"] = "NextNodeServer.getPagePath";
+    NextNodeServerSpan["getRoutesManifest"] = "NextNodeServer.getRoutesManifest";
+    NextNodeServerSpan["findPageComponents"] = "NextNodeServer.findPageComponents";
+    NextNodeServerSpan["getFontManifest"] = "NextNodeServer.getFontManifest";
+    NextNodeServerSpan["getServerComponentManifest"] = "NextNodeServer.getServerComponentManifest";
+    NextNodeServerSpan["getRequestHandler"] = "NextNodeServer.getRequestHandler";
+    NextNodeServerSpan["renderToHTML"] = "NextNodeServer.renderToHTML";
+    NextNodeServerSpan["renderError"] = "NextNodeServer.renderError";
+    NextNodeServerSpan["renderErrorToHTML"] = "NextNodeServer.renderErrorToHTML";
+    NextNodeServerSpan["render404"] = "NextNodeServer.render404";
+    NextNodeServerSpan[// nested inner span, does not require parent scope name
+    "route"] = "route";
+    NextNodeServerSpan["onProxyReq"] = "onProxyReq";
+    NextNodeServerSpan["apiResolver"] = "apiResolver";
+    NextNodeServerSpan["internalFetch"] = "internalFetch";
+})(NextNodeServerSpan || (NextNodeServerSpan = {}));
+var StartServerSpan;
+(function(StartServerSpan) {
+    StartServerSpan["startServer"] = "startServer.startServer";
+})(StartServerSpan || (StartServerSpan = {}));
+var RenderSpan;
+(function(RenderSpan) {
+    RenderSpan["getServerSideProps"] = "Render.getServerSideProps";
+    RenderSpan["getStaticProps"] = "Render.getStaticProps";
+    RenderSpan["renderToString"] = "Render.renderToString";
+    RenderSpan["renderDocument"] = "Render.renderDocument";
+    RenderSpan["createBodyResult"] = "Render.createBodyResult";
+})(RenderSpan || (RenderSpan = {}));
+var AppRenderSpan;
+(function(AppRenderSpan) {
+    AppRenderSpan["renderToString"] = "AppRender.renderToString";
+    AppRenderSpan["renderToReadableStream"] = "AppRender.renderToReadableStream";
+    AppRenderSpan["getBodyResult"] = "AppRender.getBodyResult";
+    AppRenderSpan["fetch"] = "AppRender.fetch";
+})(AppRenderSpan || (AppRenderSpan = {}));
+var RouterSpan;
+(function(RouterSpan) {
+    RouterSpan["executeRoute"] = "Router.executeRoute";
+})(RouterSpan || (RouterSpan = {}));
+var NodeSpan;
+(function(NodeSpan) {
+    NodeSpan["runHandler"] = "Node.runHandler";
+})(NodeSpan || (NodeSpan = {}));
+var AppRouteRouteHandlersSpan;
+(function(AppRouteRouteHandlersSpan) {
+    AppRouteRouteHandlersSpan["runHandler"] = "AppRouteRouteHandlers.runHandler";
+})(AppRouteRouteHandlersSpan || (AppRouteRouteHandlersSpan = {}));
+var ResolveMetadataSpan;
+(function(ResolveMetadataSpan) {
+    ResolveMetadataSpan["generateMetadata"] = "ResolveMetadata.generateMetadata";
+})(ResolveMetadataSpan || (ResolveMetadataSpan = {}));
+const NextVanillaSpanAllowlist = [
+    "BaseServer.handleRequest",
+    "Render.getServerSideProps",
+    "Render.getStaticProps",
+    "AppRender.fetch",
+    "AppRender.getBodyResult",
+    "Render.renderDocument",
+    "Node.runHandler",
+    "AppRouteRouteHandlers.runHandler",
+    "ResolveMetadata.generateMetadata"
+];
+
+//# sourceMappingURL=constants.js.map

node_modules/next/dist/server/lib/trace/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/lib/trace/constants.ts"],"names":["NextVanillaSpanAllowlist","BaseServerSpan","LoadComponentsSpan","NextServerSpan","NextNodeServerSpan","StartServerSpan","RenderSpan","RouterSpan","AppRenderSpan","NodeSpan","AppRouteRouteHandlersSpan","ResolveMetadataSpan","handleRequest","run","pipe","getStaticHTML","render","renderToResponseWithComponents","renderToResponse","renderToHTML","renderError","renderErrorToResponse","renderErrorToHTML","render404","loadDefaultErrorComponents","loadComponents","getRequestHandler","getServer","getServerRequestHandler","createServer","compression","getBuildId","generateStaticRoutes","generateFsStaticRoutes","generatePublicRoutes","generateImageRoutes","sendRenderResult","proxyRequest","runApi","renderHTML","imageOptimizer","getPagePath","getRoutesManifest","findPageComponents","getFontManifest","getServerComponentManifest","route","onProxyReq","apiResolver","internalFetch","startServer","getServerSideProps","getStaticProps","renderToString","renderDocument","createBodyResult","renderToReadableStream","getBodyResult","fetch","executeRoute","runHandler","generateMetadata"],"mappings":"AAAA;;;;;EAKE,GAEF,4CAA4C;AAC5C,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;IA6GfA,wBAAwB;eAAxBA;;IAaXC,cAAc;eAAdA;;IACAC,kBAAkB;eAAlBA;;IACAC,cAAc;eAAdA;;IACAC,kBAAkB;eAAlBA;;IACAC,eAAe;eAAfA;;IAEAC,UAAU;eAAVA;;IACAC,UAAU;eAAVA;;IACAC,aAAa;eAAbA;;IACAC,QAAQ;eAARA;;IACAC,yBAAyB;eAAzBA;;IACAC,mBAAmB;eAAnBA;;;IAnIF;UAAKV,cAAc;IAAdA,eACHW,mBAAgB;IADbX,eAEHY,SAAM;IAFHZ,eAGHa,UAAO;IAHJb,eAIHc,mBAAgB;IAJbd,eAKHe,YAAS;IALNf,eAMHgB,oCAAiC;IAN9BhB,eAOHiB,sBAAmB;IAPhBjB,eAQHkB,kBAAe;IARZlB,eASHmB,iBAAc;IATXnB,eAUHoB,2BAAwB;IAVrBpB,eAWHqB,uBAAoB;IAXjBrB,eAYHsB,eAAY;GAZTtB,mBAAAA;IAeL;UAAKC,kBAAkB;IAAlBA,mBACHsB,gCAA6B;IAD1BtB,mBAEHuB,oBAAiB;GAFdvB,uBAAAA;IAKL;UAAKC,cAAc;IAAdA,eACHuB,uBAAoB;IADjBvB,eAEHwB,eAAY;IAFTxB,eAGHyB,6BAA0B;IAHvBzB,eAIH0B,kBAAe;GAJZ1B,mBAAAA;IAOL;UAAKC,kBAAkB;IAAlBA,mBACH0B,iBAAc;IADX1B,mBAEH2B,gBAAa;IAFV3B,mBAGH4B,0BAAuB;IAHpB5B,mBAIH6B,4BAAyB;IAJtB7B,mBAKH8B,0BAAuB;IALpB9B,mBAMH+B,yBAAsB;IANnB/B,mBAOHgC,sBAAmB;IAPhBhC,mBAQHiC,kBAAe;IARZjC,mBASHkC,YAAS;IATNlC,mBAUHY,YAAS;IAVNZ,mBAWHmC,gBAAa;IAXVnC,mBAYHoC,oBAAiB;IAZdpC,mBAaHqC,iBAAc;IAbXrC,mBAcHsC,uBAAoB;IAdjBtC,mBAeHuC,wBAAqB;IAflBvC,mBAgBHwC,qBAAkB;IAhBfxC,mBAiBHyC,gCAA6B;IAjB1BzC,mBAkBHsB,uBAAoB;IAlBjBtB,mBAmBHe,kBAAe;IAnBZf,mBAoBHgB,iBAAc;IApBXhB,mBAqBHkB,uBAAoB;IArBjBlB,mBAsBHmB,eAAY;IAtBTnB,mBAwBH,wDAAwD;IACxD0C,WAAAA;IAzBG1C,mBA0BH2C,gBAAAA;IA1BG3C,mBA2BH4C,iBAAAA;IA3BG5C,mBA4BH6C,mBAAAA;GA5BG7C,uBAAAA;IA+BL;UAAKC,eAAe;IAAfA,gBACH6C,iBAAc;GADX7C,oBAAAA;IAIL;UAAKC,UAAU;IAAVA,WACH6C,wBAAqB;IADlB7C,WAEH8C,oBAAiB;IAFd9C,WAGH+C,oBAAiB;IAHd/C,WAIHgD,oBAAiB;IAJdhD,WAKHiD,sBAAmB;GALhBjD,eAAAA;IAQL;UAAKE,aAAa;IAAbA,cACH6C,oBAAiB;IADd7C,cAEHgD,4BAAyB;IAFtBhD,cAGHiD,mBAAgB;IAHbjD,cAIHkD,WAAQ;GAJLlD,kBAAAA;IAOL;UAAKD,UAAU;IAAVA,WACHoD,kBAAe;GADZpD,eAAAA;IAIL;UAAKE,QAAQ;IAARA,SACHmD,gBAAa;GADVnD,aAAAA;IAIL;UAAKC,yBAAyB;IAAzBA,0BACHkD,gBAAa;GADVlD,8BAAAA;IAIL;UAAKC,mBAAmB;IAAnBA,oBACHkD,sBAAmB;GADhBlD,wBAAAA;AAkBE,MAAMX,2BAA2B;IA1GtB;IA8DK;IACJ;IAUT;IADQ;IAPC;IAgBJ;IAIA;IAIM;CA2BpB"}

node_modules/next/dist/server/lib/trace/tracer.d.ts

@@ -0,0 +1,90 @@
+/// <reference path="../../../../types/misc.d.ts" />
+import { SpanTypes } from './constants';
+import type { ContextAPI, Span, SpanOptions, AttributeValue } from 'next/dist/compiled/@opentelemetry/api';
+declare const SpanStatusCode: typeof import("next/dist/compiled/@opentelemetry/api").SpanStatusCode, SpanKind: typeof import("next/dist/compiled/@opentelemetry/api").SpanKind;
+type TracerSpanOptions = Omit<SpanOptions, 'attributes'> & {
+    parentSpan?: Span;
+    spanName?: string;
+    attributes?: Partial<Record<AttributeNames, AttributeValue | undefined>>;
+    hideSpan?: boolean;
+};
+interface NextTracer {
+    getContext(): ContextAPI;
+    /**
+     * Instruments a function by automatically creating a span activated on its
+     * scope.
+     *
+     * The span will automatically be finished when one of these conditions is
+     * met:
+     *
+     * * The function returns a promise, in which case the span will finish when
+     * the promise is resolved or rejected.
+     * * The function takes a callback as its second parameter, in which case the
+     * span will finish when that callback is called.
+     * * The function doesn't accept a callback and doesn't return a promise, in
+     * which case the span will finish at the end of the function execution.
+     *
+     */
+    trace<T>(type: SpanTypes, fn: (span?: Span, done?: (error?: Error) => any) => Promise<T>): Promise<T>;
+    trace<T>(type: SpanTypes, fn: (span?: Span, done?: (error?: Error) => any) => T): T;
+    trace<T>(type: SpanTypes, options: TracerSpanOptions, fn: (span?: Span, done?: (error?: Error) => any) => Promise<T>): Promise<T>;
+    trace<T>(type: SpanTypes, options: TracerSpanOptions, fn: (span?: Span, done?: (error?: Error) => any) => T): T;
+    /**
+     * Wrap a function to automatically create a span activated on its
+     * scope when it's called.
+     *
+     * The span will automatically be finished when one of these conditions is
+     * met:
+     *
+     * * The function returns a promise, in which case the span will finish when
+     * the promise is resolved or rejected.
+     * * The function takes a callback as its last parameter, in which case the
+     * span will finish when that callback is called.
+     * * The function doesn't accept a callback and doesn't return a promise, in
+     * which case the span will finish at the end of the function execution.
+     */
+    wrap<T = (...args: Array<any>) => any>(type: SpanTypes, fn: T): T;
+    wrap<T = (...args: Array<any>) => any>(type: SpanTypes, options: TracerSpanOptions, fn: T): T;
+    wrap<T = (...args: Array<any>) => any>(type: SpanTypes, options: (...args: any[]) => TracerSpanOptions, fn: T): T;
+    /**
+     * Starts and returns a new Span representing a logical unit of work.
+     *
+     * This method do NOT modify the current Context by default. In result, any inner span will not
+     * automatically set its parent context to the span created by this method unless manually activate
+     * context via `tracer.getContext().with`. `trace`, or `wrap` is generally recommended as it gracefully
+     * handles context activation. (ref: https://github.com/open-telemetry/opentelemetry-js/issues/1923)
+     */
+    startSpan(type: SpanTypes): Span;
+    startSpan(type: SpanTypes, options: TracerSpanOptions): Span;
+    /**
+     * Returns currently activated span if current context is in the scope of the span.
+     * Returns undefined otherwise.
+     */
+    getActiveScopeSpan(): Span | undefined;
+}
+type NextAttributeNames = 'next.route' | 'next.page' | 'next.span_name' | 'next.span_type';
+type OTELAttributeNames = `http.${string}` | `net.${string}`;
+type AttributeNames = NextAttributeNames | OTELAttributeNames;
+declare class NextTracerImpl implements NextTracer {
+    /**
+     * Returns an instance to the trace with configured name.
+     * Since wrap / trace can be defined in any place prior to actual trace subscriber initialization,
+     * This should be lazily evaluated.
+     */
+    private getTracerInstance;
+    getContext(): ContextAPI;
+    getActiveScopeSpan(): Span | undefined;
+    trace<T>(type: SpanTypes, fn: (span?: Span, done?: (error?: Error) => any) => Promise<T>): Promise<T>;
+    trace<T>(type: SpanTypes, fn: (span?: Span, done?: (error?: Error) => any) => T): T;
+    trace<T>(type: SpanTypes, options: TracerSpanOptions, fn: (span?: Span, done?: (error?: Error) => any) => Promise<T>): Promise<T>;
+    trace<T>(type: SpanTypes, options: TracerSpanOptions, fn: (span?: Span, done?: (error?: Error) => any) => T): T;
+    wrap<T = (...args: Array<any>) => any>(type: SpanTypes, fn: T): T;
+    wrap<T = (...args: Array<any>) => any>(type: SpanTypes, options: TracerSpanOptions, fn: T): T;
+    wrap<T = (...args: Array<any>) => any>(type: SpanTypes, options: (...args: any[]) => TracerSpanOptions, fn: T): T;
+    startSpan(type: SpanTypes): Span;
+    startSpan(type: SpanTypes, options: TracerSpanOptions): Span;
+    private getSpanContext;
+    getRootSpanAttributes(): Map<AttributeNames, AttributeValue | undefined> | undefined;
+}
+declare const getTracer: () => NextTracerImpl;
+export { NextTracer, getTracer, Span, SpanOptions, ContextAPI, SpanStatusCode, TracerSpanOptions, SpanKind, };

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

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getTracer: null,
+    SpanStatusCode: null,
+    SpanKind: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getTracer: function() {
+        return getTracer;
+    },
+    SpanStatusCode: function() {
+        return SpanStatusCode;
+    },
+    SpanKind: function() {
+        return SpanKind;
+    }
+});
+const _constants = require("./constants");
+let api;
+// 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
+// this is because @opentelemetry/api has to be synced with the version of
+// @opentelemetry/tracing that is used, and we don't want to force users to use
+// the version that is bundled with Next.js.
+// the API is ~stable, so this should be fine
+if (process.env.NEXT_RUNTIME === "edge") {
+    api = require("@opentelemetry/api");
+} else {
+    try {
+        api = require("@opentelemetry/api");
+    } catch (err) {
+        api = require("next/dist/compiled/@opentelemetry/api");
+    }
+}
+const { context, trace, SpanStatusCode, SpanKind } = api;
+const isPromise = (p)=>{
+    return p !== null && typeof p === "object" && typeof p.then === "function";
+};
+const closeSpanWithError = (span, error)=>{
+    if (error) {
+        span.recordException(error);
+    }
+    span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error == null ? void 0 : error.message
+    });
+    span.end();
+};
+/** we use this map to propagate attributes from nested spans to the top span */ const rootSpanAttributesStore = new Map();
+const rootSpanIdKey = api.createContextKey("next.rootSpanId");
+let lastSpanId = 0;
+const getSpanId = ()=>lastSpanId++;
+class NextTracerImpl {
+    /**
+   * Returns an instance to the trace with configured name.
+   * Since wrap / trace can be defined in any place prior to actual trace subscriber initialization,
+   * This should be lazily evaluated.
+   */ getTracerInstance() {
+        return trace.getTracer("next.js", "0.0.1");
+    }
+    getContext() {
+        return context;
+    }
+    getActiveScopeSpan() {
+        return trace.getSpan(context == null ? void 0 : context.active());
+    }
+    trace(...args) {
+        const [type, fnOrOptions, fnOrEmpty] = args;
+        // coerce options form overload
+        const { fn, options } = typeof fnOrOptions === "function" ? {
+            fn: fnOrOptions,
+            options: {}
+        } : {
+            fn: fnOrEmpty,
+            options: {
+                ...fnOrOptions
+            }
+        };
+        if (!_constants.NextVanillaSpanAllowlist.includes(type) && process.env.NEXT_OTEL_VERBOSE !== "1" || options.hideSpan) {
+            return fn();
+        }
+        const spanName = options.spanName ?? type;
+        // 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 isRootSpan = false;
+        if (!spanContext) {
+            spanContext = api.ROOT_CONTEXT;
+            isRootSpan = true;
+        }
+        const spanId = getSpanId();
+        options.attributes = {
+            "next.span_name": spanName,
+            "next.span_type": type,
+            ...options.attributes
+        };
+        return api.context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.getTracerInstance().startActiveSpan(spanName, options, (span)=>{
+                const onCleanup = ()=>{
+                    rootSpanAttributesStore.delete(spanId);
+                };
+                if (isRootSpan) {
+                    rootSpanAttributesStore.set(spanId, new Map(Object.entries(options.attributes ?? {})));
+                }
+                try {
+                    if (fn.length > 1) {
+                        return fn(span, (err)=>closeSpanWithError(span, err));
+                    }
+                    const result = fn(span);
+                    if (isPromise(result)) {
+                        result.then(()=>span.end(), (err)=>closeSpanWithError(span, err)).finally(onCleanup);
+                    } else {
+                        span.end();
+                        onCleanup();
+                    }
+                    return result;
+                } catch (err) {
+                    closeSpanWithError(span, err);
+                    onCleanup();
+                    throw err;
+                }
+            }));
+    }
+    wrap(...args) {
+        const tracer = this;
+        const [name, options, fn] = args.length === 3 ? args : [
+            args[0],
+            {},
+            args[1]
+        ];
+        if (!_constants.NextVanillaSpanAllowlist.includes(name) && process.env.NEXT_OTEL_VERBOSE !== "1") {
+            return fn;
+        }
+        return function() {
+            let optionsObj = options;
+            if (typeof optionsObj === "function" && typeof fn === "function") {
+                optionsObj = optionsObj.apply(this, arguments);
+            }
+            const lastArgId = arguments.length - 1;
+            const cb = arguments[lastArgId];
+            if (typeof cb === "function") {
+                const scopeBoundCb = tracer.getContext().bind(context.active(), cb);
+                return tracer.trace(name, optionsObj, (_span, done)=>{
+                    arguments[lastArgId] = function(err) {
+                        done == null ? void 0 : done(err);
+                        return scopeBoundCb.apply(this, arguments);
+                    };
+                    return fn.apply(this, arguments);
+                });
+            } else {
+                return tracer.trace(name, optionsObj, ()=>fn.apply(this, arguments));
+            }
+        };
+    }
+    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);
+    }
+    getSpanContext(parentSpan) {
+        const spanContext = parentSpan ? trace.setSpan(context.active(), parentSpan) : undefined;
+        return spanContext;
+    }
+    getRootSpanAttributes() {
+        const spanId = context.active().getValue(rootSpanIdKey);
+        return rootSpanAttributesStore.get(spanId);
+    }
+}
+const getTracer = (()=>{
+    const tracer = new NextTracerImpl();
+    return ()=>tracer;
+})();
+
+//# sourceMappingURL=tracer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/lib/trace/tracer.ts"],"names":["getTracer","SpanStatusCode","SpanKind","api","process","env","NEXT_RUNTIME","require","err","context","trace","isPromise","p","then","closeSpanWithError","span","error","recordException","setStatus","code","ERROR","message","end","rootSpanAttributesStore","Map","rootSpanIdKey","createContextKey","lastSpanId","getSpanId","NextTracerImpl","getTracerInstance","getContext","getActiveScopeSpan","getSpan","active","args","type","fnOrOptions","fnOrEmpty","fn","options","NextVanillaSpanAllowlist","includes","NEXT_OTEL_VERBOSE","hideSpan","spanName","spanContext","getSpanContext","parentSpan","isRootSpan","ROOT_CONTEXT","spanId","attributes","with","setValue","startActiveSpan","onCleanup","delete","set","Object","entries","length","result","finally","wrap","tracer","name","optionsObj","apply","arguments","lastArgId","cb","scopeBoundCb","bind","_span","done","startSpan","setSpan","undefined","getRootSpanAttributes","getValue","get"],"mappings":"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"}