init: remove legacy span creation (#290)

Author: danstarns

packages/opentelemetry/src/index.ts

@@ -25,3 +25,5 @@ export {
 } from "@opentelemetry/api";
 
 export { InstrumentationOption } from "@opentelemetry/instrumentation";
+
+export { Span as ApiSpan } from "@opentelemetry/api";

packages/opentelemetry/src/run-in-span.ts

@@ -1,12 +1,12 @@
 import {
   Attributes,
   Context,
-  SpanContext,
+  Span,
   SpanKind,
   SpanStatusCode,
   Tracer,
+  trace,
 } from "@opentelemetry/api";
-import { RandomIdGenerator, Span } from "@opentelemetry/sdk-trace-base";
 
 export type RunInChildSpanOptions = {
   name: string;
@@ -16,79 +16,35 @@ export type RunInChildSpanOptions = {
   attributes?: Attributes;
 };
 
-export function createLegacySpan({
-  options,
-  parentContext,
-}: {
-  options: RunInChildSpanOptions;
-  parentContext?: SpanContext;
-}) {
-  if (parentContext) {
-    return new Span(
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      options.tracer,
-      options.context,
-      options.name,
-      {
-        traceId: parentContext.traceId,
-        spanId: new RandomIdGenerator().generateSpanId(),
-        traceFlags: 1,
-      },
-      SpanKind.INTERNAL,
-      parentContext.spanId,
-    );
-  } else {
-    return options.tracer.startActiveSpan(
-      options.name,
-      { attributes: options.attributes },
-      options.context,
-      (span): Span => {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return span;
-      },
-    );
-  }
-}
-
+/**
+ * Simplified runInSpan function to reduce complexity and improve performance.
+ * Wraps a callback within a span, setting attributes and handling errors.
+ */
 export async function runInSpan<R>(
   options: RunInChildSpanOptions,
   cb: (span: Span) => R | Promise<R>,
-) {
-  if (options.parentSpan) {
-    const parentContext = options.parentSpan.spanContext();
+): Promise<R> {
+  const { tracer, name, context, attributes } = options;
 
-    const span = createLegacySpan({ options, parentContext });
-
-    Object.entries(options.attributes || {}).forEach(([key, value]) => {
-      if (value) {
-        span.setAttribute(key, value);
-      }
-    });
+  const parentSpan = options.parentSpan;
+  const traceCTX = context;
+  const ctx = parentSpan ? trace.setSpan(traceCTX, parentSpan) : traceCTX;
 
-    try {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      return await cb(span);
-    } catch (error) {
-      const e = error as Error;
-      span.setStatus({ code: SpanStatusCode.ERROR, message: e.message });
-      span.recordException(e);
-      throw error;
-    } finally {
-      span.end();
-    }
-  }
-
-  return options.tracer.startActiveSpan(
-    options.name,
-    { attributes: options.attributes },
-    options.context,
+  return tracer.startActiveSpan(
+    name,
+    {
+      attributes,
+      kind: SpanKind.INTERNAL,
+    },
+    ctx,
     async (span) => {
       try {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
+        if (attributes) {
+          for (const [key, value] of Object.entries(attributes)) {
+            span.setAttribute(key, value as any);
+          }
+        }
+
         return await cb(span);
       } catch (error) {
         const e = error as Error;

packages/trace-directive/src/context.ts

@@ -1,6 +1,6 @@
 import {
+  ApiSpan,
   Context,
-  Span,
   Tracer,
   context,
   getTracer,
@@ -24,7 +24,7 @@ export interface GraphQLDebuggerContextOptions {
 export class GraphQLDebuggerContext {
   private context?: Context;
   public tracer: Tracer;
-  private rootSpan?: Span;
+  private rootSpan?: ApiSpan;
   public includeContext?: boolean;
   public includeVariables?: boolean;
   public includeResult?: boolean;
@@ -48,11 +48,11 @@ export class GraphQLDebuggerContext {
     return this.context;
   }
 
-  setRootSpan(span: Span) {
+  setRootSpan(span: ApiSpan) {
     this.rootSpan = span;
   }
 
-  getRootSpan(): Span | undefined {
+  getRootSpan(): ApiSpan | undefined {
     return this.rootSpan;
   }
 
@@ -80,7 +80,7 @@ export class GraphQLDebuggerContext {
     const traceCTX: Context = parentContext || context.active();
     internalCtx.setContext(traceCTX);
 
-    const currentSpan = input.graphqlContext.currentSpan as Span | undefined;
+    const currentSpan = input.graphqlContext.currentSpan as ApiSpan | undefined;
 
     return runInSpan(
       {

plugins/apollo/src/index.ts

@@ -1,14 +1,14 @@
 import { BaseAdapter } from "@graphql-debugger/adapter-base";
 import { ProxyAdapter } from "@graphql-debugger/adapter-proxy";
 import {
+  ApiSpan,
   SetupOtelInput,
-  Span,
   SpanStatusCode,
-  createLegacySpan,
   infoToAttributes,
   infoToSpanName,
   context as otelContext,
   setupOtel,
+  trace,
 } from "@graphql-debugger/opentelemetry";
 import {
   GraphQLDebuggerContext,
@@ -20,8 +20,8 @@ import { Path } from "graphql/jsutils/Path";
 
 type GraphQLContext = {
   GraphQLDebuggerContext?: GraphQLDebuggerContext;
-  parentSpan?: Span | undefined;
-  currentSpan?: Span | undefined;
+  parentSpan?: ApiSpan | undefined;
+  currentSpan?: ApiSpan | undefined;
 };
 
 function generatePathString(path: Path | undefined): string {
@@ -62,7 +62,7 @@ export const graphqlDebuggerPlugin = ({
       setupOtel({ exporterConfig, instrumentations });
     },
     requestDidStart: async () => {
-      const spanMap = new Map<string, Span>();
+      const spanMap = new Map<string, ApiSpan>();
 
       return {
         async executionDidStart(requestContext) {
@@ -82,7 +82,11 @@ export const graphqlDebuggerPlugin = ({
                 ? spanMap.get(parentPath)
                 : undefined;
 
-              const traceCTX = otelContext.active();
+              const currentContext = otelContext.active();
+
+              const ctx = parentSpan
+                ? trace.setSpan(currentContext, parentSpan)
+                : currentContext;
 
               const attributes = infoToAttributes({
                 info: fieldCtx.info,
@@ -95,19 +99,13 @@ export const graphqlDebuggerPlugin = ({
                 info: fieldCtx.info,
               });
 
-              const span = createLegacySpan({
-                options: {
-                  name: spanName,
-                  context: traceCTX,
-                  tracer: internalCtx.tracer,
+              const span = internalCtx.tracer.startSpan(
+                spanName,
+                {
                   attributes,
                 },
-                ...(parentSpan
-                  ? {
-                      parentContext: parentSpan?.spanContext(),
-                    }
-                  : {}),
-              });
+                ctx,
+              );
 
               const currentPathString = generatePathString(fieldCtx.info.path);