fix(sdk): otel v1 resource backward compatibility (#648)

Author: galkleinman

packages/traceloop-sdk/src/lib/tracing/index.ts

@@ -2,7 +2,7 @@ import { NodeSDK } from "@opentelemetry/sdk-node";
 import { SpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { context, diag } from "@opentelemetry/api";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
-import { resourceFromAttributes, Resource } from "@opentelemetry/resources";
+import { Resource } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { Instrumentation } from "@opentelemetry/instrumentation";
 import { InitializeOptions } from "../interfaces";
@@ -307,35 +307,10 @@ export const startTracing = (options: InitializeOptions) => {
     spanProcessors.push(options.processor);
   }
 
-  // Create resource with proper detection and defensive handling for OTLP serialization
-  const serviceName =
-    options.appName || process.env.npm_package_name || "unknown-service";
-  let resource: Resource;
-
-  try {
-    // Create our custom resource with service name and let NodeSDK handle default detection
-    resource = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: serviceName,
-    });
-
-    // Defensive check to prevent OTLP serialization errors
-    if (!resource || typeof resource !== "object") {
-      throw new Error("Invalid resource object");
-    }
-
-    if (!resource.attributes || typeof resource.attributes !== "object") {
-      throw new Error("Resource missing attributes");
-    }
-  } catch (error) {
-    // Fallback: create a basic resource manually
-    diag.warn(
-      "Failed to create resource with resourceFromAttributes, using fallback",
-      error,
-    );
-    resource = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: serviceName,
-    });
-  }
+  const resource = createResource({
+    [ATTR_SERVICE_NAME]:
+      options.appName || process.env.npm_package_name || "unknown_service",
+  });
 
   _sdk = new NodeSDK({
     resource,
@@ -378,3 +353,17 @@ export const shouldSendTraces = () => {
 export const forceFlush = async () => {
   await _spanProcessor.forceFlush();
 };
+
+// Compatibility function for creating resources that works with both OTel v1.x and v2.x
+function createResource(attributes: Record<string, any>): Resource {
+  // Import the resource module at runtime to handle both v1.x and v2.x
+  const resourcesModule = require("@opentelemetry/resources");
+
+  // Try to use resourceFromAttributes if it exists (OTel v2.x)
+  if (resourcesModule.resourceFromAttributes) {
+    return resourcesModule.resourceFromAttributes(attributes);
+  }
+
+  // Fallback to constructor for OTel v1.x
+  return new resourcesModule.Resource(attributes);
+}

packages/traceloop-sdk/src/lib/tracing/span-processor.ts

@@ -157,8 +157,52 @@ const onSpanStart = (span: Span): void => {
   }
 };
 
+/**
+ * Ensures span compatibility between OTel v1.x and v2.x for OTLP transformer
+ */
+const ensureSpanCompatibility = (span: ReadableSpan): ReadableSpan => {
+  const spanAny = span as any;
+
+  // If the span already has instrumentationLibrary, it's compatible (OTel v2.x)
+  if (spanAny.instrumentationLibrary) {
+    return span;
+  }
+
+  // If it has instrumentationScope but no instrumentationLibrary (OTel v1.x),
+  // add instrumentationLibrary as an alias to prevent OTLP transformer errors
+  if (spanAny.instrumentationScope) {
+    // Create a proxy that provides both properties
+    return new Proxy(span, {
+      get(target, prop) {
+        if (prop === "instrumentationLibrary") {
+          return (target as any).instrumentationScope;
+        }
+        return (target as any)[prop];
+      },
+    }) as ReadableSpan;
+  }
+
+  // Fallback: add both properties with defaults
+  return new Proxy(span, {
+    get(target, prop) {
+      if (
+        prop === "instrumentationLibrary" ||
+        prop === "instrumentationScope"
+      ) {
+        return {
+          name: "unknown",
+          version: undefined,
+          schemaUrl: undefined,
+        };
+      }
+      return (target as any)[prop];
+    },
+  }) as ReadableSpan;
+};
+
 /**
  * Handles span end event, adapting attributes for Vercel AI compatibility
+ * and ensuring OTLP transformer compatibility
  */
 const onSpanEnd = (
   originalOnEnd: (span: ReadableSpan) => void,
@@ -178,6 +222,9 @@ const onSpanEnd = (
     // Apply AI SDK transformations (if needed)
     transformAiSdkSpan(span);
 
-    originalOnEnd(span);
+    // Ensure OTLP transformer compatibility
+    const compatibleSpan = ensureSpanCompatibility(span);
+
+    originalOnEnd(compatibleSpan);
   };
 };