Initial boiler plate project

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

@@ -0,0 +1,136 @@
+/**
+ * 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 */ 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["createComponentTree"] = "NextNodeServer.createComponentTree";
+    NextNodeServerSpan["clientComponentLoading"] = "NextNodeServer.clientComponentLoading";
+    NextNodeServerSpan["getLayoutOrPageModule"] = "NextNodeServer.getLayoutOrPageModule";
+    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["startResponse"] = "NextNodeServer.startResponse";
+    // nested inner span, does not require parent scope name
+    NextNodeServerSpan["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["generateViewport"] = "ResolveMetadata.generateViewport";
+})(ResolveMetadataSpan || (ResolveMetadataSpan = {}));
+var MiddlewareSpan;
+(function(MiddlewareSpan) {
+    MiddlewareSpan["execute"] = "Middleware.execute";
+})(MiddlewareSpan || (MiddlewareSpan = {}));
+// This list is used to filter out spans that are not relevant to the user
+export const NextVanillaSpanAllowlist = [
+    "Middleware.execute",
+    "BaseServer.handleRequest",
+    "Render.getServerSideProps",
+    "Render.getStaticProps",
+    "AppRender.fetch",
+    "AppRender.getBodyResult",
+    "Render.renderDocument",
+    "Node.runHandler",
+    "AppRouteRouteHandlers.runHandler",
+    "ResolveMetadata.generateMetadata",
+    "ResolveMetadata.generateViewport",
+    "NextNodeServer.createComponentTree",
+    "NextNodeServer.findPageComponents",
+    "NextNodeServer.getLayoutOrPageModule",
+    "NextNodeServer.startResponse",
+    "NextNodeServer.clientComponentLoading"
+];
+// These Spans are allowed to be always logged
+// when the otel log prefix env is set
+export const LogSpanAllowList = [
+    "NextNodeServer.findPageComponents",
+    "NextNodeServer.createComponentTree",
+    "NextNodeServer.clientComponentLoading"
+];
+export { BaseServerSpan, LoadComponentsSpan, NextServerSpan, NextNodeServerSpan, StartServerSpan, RenderSpan, RouterSpan, AppRenderSpan, NodeSpan, AppRouteRouteHandlersSpan, ResolveMetadataSpan, MiddlewareSpan,  };
+
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/lib/trace/constants.ts"],"names":["BaseServerSpan","LoadComponentsSpan","NextServerSpan","NextNodeServerSpan","StartServerSpan","RenderSpan","AppRenderSpan","RouterSpan","NodeSpan","AppRouteRouteHandlersSpan","ResolveMetadataSpan","MiddlewareSpan","NextVanillaSpanAllowlist","LogSpanAllowList"],"mappings":"AAAA;;;;;EAKE,GAEF,4CAA4C;AAC5C,4BAA4B;UAEvBA;;;;;;;;;;;;;GAAAA,mBAAAA;;UAeAC;;;GAAAA,uBAAAA;;UAKAC;;;;;GAAAA,mBAAAA;;UAOAC;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4BH,wDAAwD;;;;;GA5BrDA,uBAAAA;;UAmCAC;;GAAAA,oBAAAA;;UAIAC;;;;;;GAAAA,eAAAA;;UAQAC;;;;;GAAAA,kBAAAA;;UAOAC;;GAAAA,eAAAA;;UAIAC;;GAAAA,aAAAA;;UAIAC;;GAAAA,8BAAAA;;UAIAC;;;GAAAA,wBAAAA;;UAKAC;;GAAAA,mBAAAA;AAkBL,0EAA0E;AAC1E,OAAO,MAAMC,2BAA2B;;;;;;;;;;;;;;;;;CAiBvC,CAAA;AAED,8CAA8C;AAC9C,sCAAsC;AACtC,OAAO,MAAMC,mBAAmB;;;;CAI/B,CAAA;AAED,SACEb,cAAc,EACdC,kBAAkB,EAClBC,cAAc,EACdC,kBAAkB,EAClBC,eAAe,EACfC,UAAU,EACVE,UAAU,EACVD,aAAa,EACbE,QAAQ,EACRC,yBAAyB,EACzBC,mBAAmB,EACnBC,cAAc,KACf"}

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

@@ -0,0 +1,189 @@
+import { LogSpanAllowList, NextVanillaSpanAllowlist } from "./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, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api;
+const isPromise = (p)=>{
+    return p !== null && typeof p === "object" && typeof p.then === "function";
+};
+const closeSpanWithError = (span, error)=>{
+    if ((error == null ? void 0 : error.bubble) === true) {
+        span.setAttribute("next.bubble", true);
+    } else {
+        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());
+    }
+    withPropagatedContext(carrier, fn, getter) {
+        const activeContext = context.active();
+        if (trace.getSpanContext(activeContext)) {
+            // Active span is already set, too late to propagate.
+            return fn();
+        }
+        const remoteContext = propagation.extract(activeContext, carrier, getter);
+        return context.with(remoteContext, fn);
+    }
+    trace(...args) {
+        var _trace_getSpanContext;
+        const [type, fnOrOptions, fnOrEmpty] = args;
+        // coerce options form overload
+        const { fn, options } = typeof fnOrOptions === "function" ? {
+            fn: fnOrOptions,
+            options: {}
+        } : {
+            fn: fnOrEmpty,
+            options: {
+                ...fnOrOptions
+            }
+        };
+        const spanName = options.spanName ?? type;
+        if (!NextVanillaSpanAllowlist.includes(type) && process.env.NEXT_OTEL_VERBOSE !== "1" || 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 isRootSpan = false;
+        if (!spanContext) {
+            spanContext = (context == null ? void 0 : context.active()) ?? ROOT_CONTEXT;
+            isRootSpan = true;
+        } else if ((_trace_getSpanContext = trace.getSpanContext(spanContext)) == null ? void 0 : _trace_getSpanContext.isRemote) {
+            isRootSpan = true;
+        }
+        const spanId = getSpanId();
+        options.attributes = {
+            "next.span_name": spanName,
+            "next.span_type": type,
+            ...options.attributes
+        };
+        return context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.getTracerInstance().startActiveSpan(spanName, options, (span)=>{
+                const startTime = "performance" in globalThis ? globalThis.performance.now() : undefined;
+                const onCleanup = ()=>{
+                    rootSpanAttributesStore.delete(spanId);
+                    if (startTime && process.env.NEXT_OTEL_PERFORMANCE_PREFIX && LogSpanAllowList.includes(type || "")) {
+                        performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-${(type.split(".").pop() || "").replace(/[A-Z]/g, (match)=>"-" + match.toLowerCase())}`, {
+                            start: startTime,
+                            end: performance.now()
+                        });
+                    }
+                };
+                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)) {
+                        // If there's error make sure it throws
+                        return result.then((res)=>{
+                            span.end();
+                            // Need to pass down the promise result,
+                            // it could be react stream response with error { error, stream }
+                            return res;
+                        }).catch((err)=>{
+                            closeSpanWithError(span, err);
+                            throw 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 (!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;
+})();
+export { getTracer, SpanStatusCode, SpanKind };
+
+//# sourceMappingURL=tracer.js.map