Replace tracing with OpenTelemetry

Author: danopia

Dockerfile

@@ -1,4 +1,4 @@
-FROM denoland/deno:alpine-1.30.1
+FROM denoland/deno:alpine-1.31.1
 RUN apk add --no-cache graphviz
 ADD fonts/ /usr/share/fonts/truetype/
 
@@ -7,4 +7,4 @@ ADD deps.ts .
 RUN deno check deps.ts
 ADD . .
 RUN deno check server.ts
-ENTRYPOINT ["deno","run","--allow-env","--allow-net","--allow-run=deno,dot","--allow-read=.","server.ts"]
+ENTRYPOINT ["deno","run","--allow-sys=hostname","--allow-env","--allow-net","--allow-run=deno,dot","--allow-read=.","server.ts"]

deps.ts

@@ -18,3 +18,5 @@ export type {
   ModuleGraphJson,
   ModuleJson,
 } from "https://deno.land/x/[email protected]/lib/types.d.ts";
+
+export { trace, context, type Context } from "npm:@opentelemetry/api";

feat/dependencies-of/api.ts

@@ -4,13 +4,17 @@ import {
   readableStreamFromIterable,
   SubProcess,
   type SubprocessErrorData,
+  trace,
+context,
+Context,
 } from "../../deps.ts";
-import { getTraceContext } from "../../gcp-tracing.ts";
 
 import { templateHtml, makeErrorResponse, HtmlHeaders } from '../../lib/request-handling.ts';
 import { findModuleSlug, resolveModuleUrl } from "../../lib/resolve.ts";
 import { computeGraph, renderGraph } from "./compute.ts";
 
+const tracer = trace.getTracer('dependencies-of-api');
+
 export async function *handleRequest(req: Request, modSlug: string, args: URLSearchParams) {
   if (modSlug == '') {
     const url = args.get('url');
@@ -78,20 +82,15 @@ const hideLoadMsg = `<style type="text/css">#graph-waiting { display: none; }</s
 
 async function serveHtmlGraphPage(req: Request, modUrl: string, modSlug: string, args: URLSearchParams) {
   args.set('font', 'Archivo Narrow');
-  const ctx = getTraceContext()!;
 
   // Render the basic page first, so we can error more cleanly if that fails
   let pageHtml = '';
   try {
-    pageHtml = await ctx.enterSpan({
-      spanKind: 'INTERNAL',
-      displayName: {value: 'Render page HTML'},
-      startTime: new Date().toISOString(),
-    }, () => templateHtml('feat/dependencies-of/public.html', {
+    pageHtml = await templateHtml('feat/dependencies-of/public.html', {
       module_slug: entities.encode(modSlug),
       module_url: entities.encode(modUrl),
       export_prefix: entities.encode(`${req.url}${req.url.includes('?') ? '&' : '?'}format=`),
-    }));
+    });
   } catch (err) {
     return makeErrorResponse(err);
   }
@@ -149,28 +148,44 @@ async function serveHtmlGraphPage(req: Request, modUrl: string, modSlug: string,
   });
 
   // Return the body in two parts, with a comment in between
-  return new Response(readableStreamFromIterable((async function*() {
+
+  async function* bodyGenerator() {
     try {
       const encoder = new TextEncoder();
       yield encoder.encode(pageHtml);
 
       yield encoder.encode("\n<!-- now waiting for graph ... ");
       const d0 = Date.now();
-      const graphText = await ctx.enterSpan({
-        spanKind: "INTERNAL",
-        startTime: new Date().toISOString(),
-        displayName: {value: "Wait for graph text"},
-      }, async () => hideLoadMsg + await graphPromise);
+      const span = tracer.startSpan('Wait for graph text');
+      const graphText = hideLoadMsg + await graphPromise.finally(() => span.end());
       const millis = Date.now() - d0;
       yield encoder.encode(`completed in ${millis}ms -->\n\n`);
 
       yield encoder.encode(graphText);
-
-      ctx.spans[0].endTime = new Date().toISOString(); // TODO: ugh
     } catch (err) {
       console.error(err)
     }
-  }())), {
+  }
+
+  const bodyIterable = asyncGeneratorWithContext(context.active(), bodyGenerator);
+  return new Response(readableStreamFromIterable(bodyIterable), {
     headers: HtmlHeaders,
   });
 }
+
+async function* asyncGeneratorWithContext<T, TReturn, TNext>(
+  operationContext: Context,
+  operation: () => AsyncGenerator<T, TReturn, TNext>,
+): AsyncGenerator<T, TReturn, TNext> {
+  const generator = context.with(operationContext, operation)
+  const next = context.bind(operationContext, generator.next.bind(generator))
+
+  let result: IteratorResult<T, TReturn> = await next()
+
+  while (!result.done) {
+    const nextParam = yield result.value
+    result = await next(nextParam)
+  }
+
+  return result.value
+}

feat/dependencies-of/compute.ts

@@ -1,51 +1,53 @@
-import { ModuleGraphJson, SubProcess } from "../../deps.ts";
-import { getTraceContext } from "../../gcp-tracing.ts";
+import { ModuleGraphJson, SubProcess, trace } from "../../deps.ts";
 import { computeDependencies } from "../../lib/module-map.ts";
 
+const tracer = trace.getTracer('dependencies-of-compute');
+
 export async function computeGraph(
   modUrl: string,
   args: URLSearchParams,
   format?: string,
 ) {
   if (format) args.set('format', format);
 
-  const ctx = getTraceContext()!;
+  const dlSpan = tracer.startSpan('deno info --json', {
+    attributes: {
+      'module_url': modUrl,
+    },
+  });
 
-  const downloadData = await ctx.enterSpan({
-    displayName: {value: 'deno info --json'},
-    startTime: new Date().toISOString(),
-    spanKind: "INTERNAL",
-  }, async () => JSON.parse(await new SubProcess('download', {
+  const downloadData = JSON.parse(await new SubProcess('download', {
     cmd: ["deno", "info", "--json", "--", modUrl],
     env: { "NO_COLOR": "yas" },
     stdin: 'null',
     errorPrefix: /^error: /,
-  }).captureAllTextOutput()) as ModuleGraphJson);
-
-  return await ctx.enterSpan({
-    spanKind: 'INTERNAL',
-    displayName: {value: 'Compute graph'},
-    startTime: new Date().toISOString(),
-  }, async () => computeDependencies(downloadData, args));
+  }).captureAllTextOutput().finally(() => dlSpan.end())) as ModuleGraphJson;
+
+  const computeSpan = tracer.startSpan('Compute graph');
+  try {
+    return computeDependencies(downloadData, args);
+  } finally {
+    computeSpan.end();
+  }
 }
 
 export async function renderGraph(modUrl: string, dotArgs: string[], args: URLSearchParams) {
-  const ctx = getTraceContext()!;
+  return tracer.startActiveSpan('Compute + Render Graph', span =>
+    renderGraphInner(modUrl, dotArgs, args).finally(() => span.end()));
+}
+async function renderGraphInner(modUrl: string, dotArgs: string[], args: URLSearchParams) {
   const dotText = await computeGraph(modUrl, args, 'dot');
 
+  const span = tracer.startSpan('graphviz');
+
   const dotProc = new SubProcess('render', {
     cmd: ["dot", ...dotArgs],
     stdin: 'piped',
     errorPrefix: /^Error: /,
   });
   await dotProc.writeInputText(dotText);
 
-  ctx.enterSpan({
-    spanKind: 'INTERNAL',
-    displayName: {value: 'graphviz'},
-    startTime: new Date().toISOString(),
-    sameProcessAsParentSpan: false,
-  }, () => dotProc.status());
+  dotProc.status().finally(() => span.end());
 
   return dotProc;
 }