feat: clean up tracing impl

Author: shrugs

…@breadcrumbs/(apis)/api/graphql/page.tsx …readcrumbs/(apis)/api/omnigraph/page.tsxapps/ensadmin/src/app/@breadcrumbs/(apis)/api/graphql/page.tsx renamed to apps/ensadmin/src/app/@breadcrumbs/(apis)/api/omnigraph/page.tsx apps/ensadmin/src/app/@breadcrumbs/(apis)/api/graphql/page.tsx renamed to apps/ensadmin/src/app/@breadcrumbs/(apis)/api/omnigraph/page.tsx

@@ -3,7 +3,7 @@ import { BreadcrumbItem, BreadcrumbPage } from "@/components/ui/breadcrumb";
 export default function Page() {
   return (
     <BreadcrumbItem>
-      <BreadcrumbPage>GraphQL API (ENS v1 + v2)</BreadcrumbPage>
+      <BreadcrumbPage>Omnigraph API (ENS v1 + v2)</BreadcrumbPage>
     </BreadcrumbItem>
   );
 }

apps/ensapi/src/omnigraph-api/builder.ts

@@ -2,7 +2,7 @@ import { trace } from "@opentelemetry/api";
 import SchemaBuilder, { type MaybePromise } from "@pothos/core";
 import DataloaderPlugin from "@pothos/plugin-dataloader";
 import RelayPlugin from "@pothos/plugin-relay";
-import TracingPlugin, { isRootField } from "@pothos/plugin-tracing";
+import TracingPlugin from "@pothos/plugin-tracing";
 import { createOpenTelemetryWrapper } from "@pothos/tracing-opentelemetry";
 import type {
   ChainId,
@@ -24,7 +24,25 @@ import type { Address, Hex } from "viem";
 import type { context } from "@/omnigraph-api/context";
 
 const tracer = trace.getTracer("graphql");
-const createSpan = createOpenTelemetryWrapper(tracer, { includeArgs: true, includeSource: false });
+const createSpan = createOpenTelemetryWrapper(tracer, {
+  includeArgs: true,
+  includeSource: false,
+  onSpan: (span, options, parent, args, ctx, info) => {
+    // edge field names are too loud by default and not helpful
+    if (info.fieldName === "edges") return span.updateName("edges");
+
+    // turn a node field name into "Typename([:id])"
+    if (info.fieldName === "node") {
+      const typename = (info.returnType as any).name;
+      const id = (parent as any).node.id;
+
+      return span.updateName(`${typename}(${id})`);
+    }
+
+    // otherwise name the span as "Typename.fieldName"
+    return span.updateName(`${info.parentType.name}.${info.fieldName}`);
+  },
+});
 
 export const builder = new SchemaBuilder<{
   Context: ReturnType<typeof context>;
@@ -54,7 +72,7 @@ export const builder = new SchemaBuilder<{
 }>({
   plugins: [TracingPlugin, DataloaderPlugin, RelayPlugin],
   tracing: {
-    default: (config) => isRootField(config),
+    default: () => true,
     wrap: (resolver, options) => createSpan(resolver, options),
   },
   relay: {

apps/ensapi/src/omnigraph-api/lib/find-domains/find-domains-resolver.ts

@@ -3,7 +3,7 @@ import { type ResolveCursorConnectionArgs, resolveCursorConnection } from "@poth
 import { and, count } from "drizzle-orm";
 
 import { ensDb } from "@/lib/ensdb/singleton";
-import { withSpanAsync } from "@/lib/instrumentation/auto-span";
+import { withActiveSpanAsync } from "@/lib/instrumentation/auto-span";
 import { makeLogger } from "@/lib/logger";
 import type { context as createContext } from "@/omnigraph-api/context";
 import type {
@@ -100,7 +100,7 @@ export function resolveFindDomains(
 
   return lazyConnection({
     totalCount: () =>
-      withSpanAsync(tracer, "totalCount", {}, async () => {
+      withActiveSpanAsync(tracer, "find-domains.totalCount", {}, async () => {
         const rows = await ensDb.with(domains).select({ count: count() }).from(domains);
         return rows[0].count;
       }),
@@ -149,17 +149,17 @@ export function resolveFindDomains(
           logger.debug({ sql: query.toSQL() });
 
           // execute paginated query
-          const results = await withSpanAsync(
+          const results = await withActiveSpanAsync(
             tracer,
-            "connection",
+            "find-domains.connection",
             { orderBy, orderDir, limit },
             () => query.execute(),
           );
 
           // load Domain entities via dataloader
-          const loadedDomains = await withSpanAsync(
+          const loadedDomains = await withActiveSpanAsync(
             tracer,
-            "dataloader",
+            "find-domains.dataloader",
             { count: results.length },
             () =>
               rejectAnyErrors(

apps/ensapi/src/omnigraph-api/lib/get-domain-by-interpreted-name.ts

@@ -1,5 +1,6 @@
 import config from "@/config";
 
+import { trace } from "@opentelemetry/api";
 import { Param, sql } from "drizzle-orm";
 import { namehash } from "viem";
 
@@ -16,13 +17,15 @@ import {
 } from "@ensnode/ensnode-sdk";
 
 import { ensDb, ensIndexerSchema } from "@/lib/ensdb/singleton";
+import { withActiveSpanAsync } from "@/lib/instrumentation/auto-span";
 import { lazy } from "@/lib/lazy";
 import { makeLogger } from "@/lib/logger";
 
 // lazy() defers construction until first use so that this module can be
 // imported without env vars being present (e.g. during OpenAPI generation).
-const getRootRegistryId = lazy(() => maybeGetENSv2RootRegistryId(config.namespace));
+const _maybeGetENSv2RootRegistryId = lazy(() => maybeGetENSv2RootRegistryId(config.namespace));
 
+const tracer = trace.getTracer("get-domain-by-interpreted-name");
 const logger = makeLogger("get-domain-by-interpreted-name");
 const v1Logger = makeLogger("get-domain-by-interpreted-name:v1");
 const v2Logger = makeLogger("get-domain-by-interpreted-name:v2");
@@ -63,18 +66,27 @@ const v2Logger = makeLogger("get-domain-by-interpreted-name:v2");
 export async function getDomainIdByInterpretedName(
   name: InterpretedName,
 ): Promise<DomainId | null> {
-  // Domains addressable in v2 are preferred, but v1 lookups are cheap, so just do them both ahead of time
-  const rootRegistryId = getRootRegistryId();
-  const [v1DomainId, v2DomainId] = await Promise.all([
-    v1_getDomainIdByInterpretedName(name),
-    // only resolve v2Domain if ENSv2 Root Registry is defined
-    rootRegistryId ? v2_getDomainIdByInterpretedName(rootRegistryId, name) : null,
-  ]);
-
-  logger.debug({ v1DomainId, v2DomainId });
-
-  // prefer v2Domain over v1Domain
-  return v2DomainId || v1DomainId || null;
+  return withActiveSpanAsync(tracer, "getDomainIdByInterpretedName", { name }, async () => {
+    // Domains addressable in v2 are preferred, but v1 lookups are cheap, so just do them both ahead of time
+    const rootRegistryId = _maybeGetENSv2RootRegistryId();
+
+    const [v1DomainId, v2DomainId] = await Promise.all([
+      withActiveSpanAsync(tracer, "v1_getDomainId", {}, () =>
+        v1_getDomainIdByInterpretedName(name),
+      ),
+      // only resolve v2Domain if ENSv2 Root Registry is defined
+      rootRegistryId
+        ? withActiveSpanAsync(tracer, "v2_getDomainId", {}, () =>
+            v2_getDomainIdByInterpretedName(rootRegistryId, name),
+          )
+        : null,
+    ]);
+
+    logger.debug({ v1DomainId, v2DomainId });
+
+    // prefer v2Domain over v1Domain
+    return v2DomainId || v1DomainId || null;
+  });
 }
 
 /**

apps/ensapi/src/omnigraph-api/schema/domain.ts

@@ -1,3 +1,4 @@
+import { trace } from "@opentelemetry/api";
 import { type ResolveCursorConnectionArgs, resolveCursorConnection } from "@pothos/plugin-relay";
 import { and, count, eq, getTableColumns } from "drizzle-orm";
 
@@ -9,6 +10,7 @@ import {
 } from "@ensnode/ensnode-sdk";
 
 import { ensDb, ensIndexerSchema } from "@/lib/ensdb/singleton";
+import { withSpanAsync } from "@/lib/instrumentation/auto-span";
 import { builder } from "@/omnigraph-api/builder";
 import {
   orderPaginationBy,
@@ -41,6 +43,7 @@ import { RegistrationInterfaceRef } from "@/omnigraph-api/schema/registration";
 import { RegistryRef } from "@/omnigraph-api/schema/registry";
 import { ResolverRef } from "@/omnigraph-api/schema/resolver";
 
+const tracer = trace.getTracer("schema/Domain");
 const isENSv1Domain = (domain: Domain): domain is ENSv1Domain => "parentId" in domain;
 
 /////////////////////////////
@@ -49,21 +52,25 @@ const isENSv1Domain = (domain: Domain): domain is ENSv1Domain => "parentId" in d
 
 export const ENSv1DomainRef = builder.loadableObjectRef("ENSv1Domain", {
   load: (ids: ENSv1DomainId[]) =>
-    ensDb.query.v1Domain.findMany({
-      where: (t, { inArray }) => inArray(t.id, ids),
-      with: { label: true },
-    }),
+    withSpanAsync(tracer, "ENSv1Domain.load", { count: ids.length }, () =>
+      ensDb.query.v1Domain.findMany({
+        where: (t, { inArray }) => inArray(t.id, ids),
+        with: { label: true },
+      }),
+    ),
   toKey: getModelId,
   cacheResolved: true,
   sort: true,
 });
 
 export const ENSv2DomainRef = builder.loadableObjectRef("ENSv2Domain", {
   load: (ids: ENSv2DomainId[]) =>
-    ensDb.query.v2Domain.findMany({
-      where: (t, { inArray }) => inArray(t.id, ids),
-      with: { label: true },
-    }),
+    withSpanAsync(tracer, "ENSv2Domain.load", { count: ids.length }, () =>
+      ensDb.query.v2Domain.findMany({
+        where: (t, { inArray }) => inArray(t.id, ids),
+        with: { label: true },
+      }),
+    ),
   toKey: getModelId,
   cacheResolved: true,
   sort: true,