Removed tracing that breaks tests

Author: matt-aitken

apps/webapp/app/runEngine/concerns/waitpointCompletionPacket.server.ts

@@ -1,9 +1,8 @@
-import { IOPacket, packetRequiresOffloading, tryCatch } from "@trigger.dev/core/v3";
+import { type IOPacket, packetRequiresOffloading, tryCatch } from "@trigger.dev/core/v3";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { env } from "~/env.server";
 import { uploadPacketToObjectStore } from "~/v3/objectStore.server";
 import { ServiceValidationError } from "~/v3/services/common.server";
-import { startActiveSpan } from "~/v3/tracer.server";
 
 function packetExtensionForDataType(dataType: string): string {
   switch (dataType) {
@@ -28,42 +27,37 @@ export async function processWaitpointCompletionPacket(
   environment: AuthenticatedEnvironment,
   pathPrefix: string
 ): Promise<IOPacket> {
-  return await startActiveSpan("processWaitpointCompletionPacket()", async (span) => {
-    if (!packet.data) {
-      return packet;
-    }
-
-    const { needsOffloading, size } = packetRequiresOffloading(
-      packet,
-      env.TASK_PAYLOAD_OFFLOAD_THRESHOLD
-    );
+  if (!packet.data) {
+    return packet;
+  }
 
-    span.setAttribute("needsOffloading", needsOffloading);
-    span.setAttribute("size", size);
+  const { needsOffloading, size } = packetRequiresOffloading(
+    packet,
+    env.TASK_PAYLOAD_OFFLOAD_THRESHOLD
+  );
 
-    if (!needsOffloading) {
-      return packet;
-    }
+  if (!needsOffloading) {
+    return packet;
+  }
 
-    const filename = `${pathPrefix}.${packetExtensionForDataType(packet.dataType)}`;
+  const filename = `${pathPrefix}.${packetExtensionForDataType(packet.dataType)}`;
 
-    const [uploadError, uploadedFilename] = await tryCatch(
-      uploadPacketToObjectStore(
-        filename,
-        packet.data,
-        packet.dataType,
-        environment,
-        env.OBJECT_STORE_DEFAULT_PROTOCOL
-      )
-    );
+  const [uploadError, uploadedFilename] = await tryCatch(
+    uploadPacketToObjectStore(
+      filename,
+      packet.data,
+      packet.dataType,
+      environment,
+      env.OBJECT_STORE_DEFAULT_PROTOCOL
+    )
+  );
 
-    if (uploadError) {
-      throw new ServiceValidationError("Failed to upload large waitpoint to object store", 500);
-    }
+  if (uploadError) {
+    throw new ServiceValidationError("Failed to upload large waitpoint to object store", 500);
+  }
 
-    return {
-      data: uploadedFilename!,
-      dataType: "application/store",
-    };
-  });
+  return {
+    data: uploadedFilename!,
+    dataType: "application/store",
+  };
 }

apps/webapp/app/v3/objectStore.server.ts

@@ -1,10 +1,8 @@
+import { type IOPacket } from "@trigger.dev/core/v3";
 import { env } from "~/env.server";
-import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
 import { singleton } from "~/utils/singleton";
-import { tracer } from "~/v3/tracer.server";
-import { startSpan } from "~/v3/tracing.server";
-import { IOPacket } from "@trigger.dev/core/v3";
 import { ObjectStoreClient, type ObjectStoreClientConfig } from "./objectStoreClient.server";
 
 /**
@@ -129,30 +127,21 @@ export async function uploadPacketToObjectStore(
   environment: AuthenticatedEnvironment,
   storageProtocol?: string
 ): Promise<string> {
-  return await startSpan(tracer, "uploadPacketToObjectStore()", async (span) => {
-    const protocol = storageProtocol || env.OBJECT_STORE_DEFAULT_PROTOCOL;
-    const client = getObjectStoreClient(protocol);
+  const protocol = storageProtocol || env.OBJECT_STORE_DEFAULT_PROTOCOL;
+  const client = getObjectStoreClient(protocol);
 
-    if (!client) {
-      throw new Error(`Object store is not configured for protocol: ${protocol || "default"}`);
-    }
-
-    span.setAttributes({
-      projectRef: environment.project.externalRef,
-      environmentSlug: environment.slug,
-      filename,
-      protocol: protocol || "default",
-    });
+  if (!client) {
+    throw new Error(`Object store is not configured for protocol: ${protocol || "default"}`);
+  }
 
-    const key = `packets/${environment.project.externalRef}/${environment.slug}/${filename}`;
+  const key = `packets/${environment.project.externalRef}/${environment.slug}/${filename}`;
 
-    logger.debug("Uploading to object store", { key, protocol: protocol || "default" });
+  logger.debug("Uploading to object store", { key, protocol: protocol || "default" });
 
-    await client.putObject(key, data, contentType);
+  await client.putObject(key, data, contentType);
 
-    // Return filename with protocol prefix if specified
-    return formatStorageUri(filename, protocol);
-  });
+  // Return filename with protocol prefix if specified
+  return formatStorageUri(filename, protocol);
 }
 
 export async function downloadPacketFromObjectStore(
@@ -163,38 +152,29 @@ export async function downloadPacketFromObjectStore(
     return packet;
   }
 
-  return await startSpan(tracer, "downloadPacketFromObjectStore()", async (span) => {
-    // There shouldn't be an offloaded packet with undefined data…
-    if (!packet.data) {
-      logger.error("Object store packet has undefined data", { packet, environment });
-      return {
-        dataType: "application/json",
-        data: undefined,
-      };
-    }
-
-    const { protocol, path } = parseStorageUri(packet.data);
-    const client = getObjectStoreClient(protocol);
+  // There shouldn't be an offloaded packet with undefined data…
+  if (!packet.data) {
+    logger.error("Object store packet has undefined data", { packet, environment });
+    return {
+      dataType: "application/json",
+      data: undefined,
+    };
+  }
 
-    if (!client) {
-      throw new Error(`Object store is not configured for protocol: ${protocol || "default"}`);
-    }
+  const { protocol, path } = parseStorageUri(packet.data);
+  const client = getObjectStoreClient(protocol);
 
-    span.setAttributes({
-      projectRef: environment.project.externalRef,
-      environmentSlug: environment.slug,
-      filename: packet.data,
-      protocol: protocol || "default",
-    });
+  if (!client) {
+    throw new Error(`Object store is not configured for protocol: ${protocol || "default"}`);
+  }
 
-    const key = `packets/${environment.project.externalRef}/${environment.slug}/${path}`;
+  const key = `packets/${environment.project.externalRef}/${environment.slug}/${path}`;
 
-    logger.debug("Downloading from object store", { key, protocol: protocol || "default" });
+  logger.debug("Downloading from object store", { key, protocol: protocol || "default" });
 
-    const data = await client.getObject(key);
+  const data = await client.getObject(key);
 
-    return { data, dataType: "application/json" };
-  });
+  return { data, dataType: "application/json" };
 }
 
 export type GeneratePacketPresignOptions = {