Keep the safe() span-builder helper instead of inlining try/catch

Author: andreiborza

packages/server-utils/src/integrations/tracing-channel/aws-sdk/index.ts

@@ -44,6 +44,16 @@ interface AwsV3Command {
   constructor?: { name?: string };
 }
 
+/** Runs a span-building callback so a throw inside it can never break the user's aws-sdk call. */
+function safe<T>(fn: () => T): T | undefined {
+  try {
+    return fn();
+  } catch (error) {
+    DEBUG_BUILD && debug.warn('[orchestrion:aws-sdk] error building span', error);
+    return undefined;
+  }
+}
+
 // `metadata` is smithy's `ResponseMetadata`, read off the untyped channel result/error (`any` for the
 // same reason as `CommandInput`, see types.ts).
 function setMetadataAttributes(span: Span, metadata: Record<string, any> | undefined): void {
@@ -73,10 +83,8 @@ const _awsChannelIntegration = (() => {
         return;
       }
 
-      // Everything in here (and in `deferSpanEnd` below) runs inside the tracingChannel machinery
-      // wrapping the user's `send` call, so a throw must never escape: it would break the AWS call.
-      const getSpan = (data: AwsSendChannelContext): Span | undefined => {
-        try {
+      const getSpan = (data: AwsSendChannelContext): Span | undefined =>
+        safe(() => {
           const command = data.arguments[0] as AwsV3Command | undefined;
           const commandName = command?.constructor?.name;
           if (!command || !commandName) {
@@ -125,7 +133,7 @@ const _awsChannelIntegration = (() => {
           // so `cloud.region` cannot be lost when `send` settles first (e.g. an early failure).
           //
           // The provider call is guarded separately: the span is already started, so a synchronous
-          // throw bubbling into the enclosing catch would discard it without ending it (a leaked
+          // throw bubbling into the enclosing `safe` would discard it without ending it (a leaked
           // open span).
           let regionResult: string | Promise<string> | undefined;
           try {
@@ -153,20 +161,11 @@ const _awsChannelIntegration = (() => {
           data._sentryRegion = regionHolder;
 
           // Inject trace-propagation headers into outgoing messages (SQS/SNS/Lambda). Runs before
-          // `send` proceeds, so the mutated `commandInput` is used to build the request. Guarded
-          // separately so a throw can't discard the already-started span via the outer catch.
-          try {
-            servicesExtensions.requestPostSpanHook(normalizedRequest, span);
-          } catch (error) {
-            DEBUG_BUILD && debug.warn('[orchestrion:aws-sdk] error in request post-span hook', error);
-          }
+          // `send` proceeds, so the mutated `commandInput` is used to build the request.
+          safe(() => servicesExtensions.requestPostSpanHook(normalizedRequest, span));
 
           return span;
-        } catch (error) {
-          DEBUG_BUILD && debug.warn('[orchestrion:aws-sdk] error building span', error);
-          return undefined;
-        }
-      };
+        });
 
       const opts: TracingChannelLifeCycleOptions<AwsSendChannelContext> = {
         deferSpanEnd({ span, data, end }) {
@@ -179,9 +178,8 @@ const _awsChannelIntegration = (() => {
           const failed = 'error' in data;
 
           // The channel `result`/`error` are untyped; the `$metadata` casts below name smithy's
-          // `ResponseMetadata` shape (`any`-valued, see `setMetadataAttributes`). Guarded so an
-          // enrichment throw can't escape into the user's `send` (see `getSpan`).
-          try {
+          // `ResponseMetadata` shape (`any`-valued, see `setMetadataAttributes`).
+          safe(() => {
             if (failed) {
               const err = data.error as
                 | { $metadata?: Record<string, any>; RequestId?: string; extendedRequestId?: string }
@@ -195,20 +193,19 @@ const _awsChannelIntegration = (() => {
                 httpStatusCode: errMetadata?.httpStatusCode,
                 extendedRequestId: err?.extendedRequestId ?? errMetadata?.extendedRequestId,
               });
-            } else {
-              const output = data.result as { $metadata?: Record<string, any> } | undefined;
-              setMetadataAttributes(span, output?.$metadata);
-
-              const normalizedResponse: NormalizedResponse = {
-                data: output,
-                request: normalizedRequest,
-                requestId: output?.$metadata?.requestId,
-              };
-              servicesExtensions.responseHook(normalizedResponse, span);
+              return;
             }
-          } catch (error) {
-            DEBUG_BUILD && debug.warn('[orchestrion:aws-sdk] error enriching span', error);
-          }
+
+            const output = data.result as { $metadata?: Record<string, any> } | undefined;
+            setMetadataAttributes(span, output?.$metadata);
+
+            const normalizedResponse: NormalizedResponse = {
+              data: output,
+              request: normalizedRequest,
+              requestId: output?.$metadata?.requestId,
+            };
+            servicesExtensions.responseHook(normalizedResponse, span);
+          });
 
           // Streaming responses end the span when their wrapped stream is consumed (see
           // bedrock-runtime); the helper must not end it on `send` settling. Errors always end here.