fix: decode scope version/attributes, handle missing status, and fix Effect error handling

- Read scopeVersion and scopeAttributes from scopeSpan.scope instead of
  hardcoding undefined/{} in decodeOtlpTraceRecords
- Add null guard in decodeStatus to return undefined when span status is missing
- Fix Effect.try catch handler to return a plain error value and use
  Effect.catch to actually execute the warning log
- Make span array fields (attributes, events, links) tolerant of missing values
- Convert OTLP intValue from string to number in decodeValue

Author: cursoragent

apps/server/src/http.ts

@@ -39,12 +39,15 @@ export const otlpTracesProxyRouteLayer = HttpRouter.add(
 
     yield* Effect.try({
       try: () => decodeOtlpTraceRecords(bodyJson),
-      catch: (cause) =>
+      catch: (cause) => ({ _tag: "DecodeError" as const, cause }),
+    }).pipe(
+      Effect.flatMap((records) => browserTraceCollector.record(records)),
+      Effect.catch(() =>
         Effect.logWarning("Failed to decode browser OTLP traces", {
-          cause,
           bodyJson,
         }),
-    }).pipe(Effect.flatMap((records) => browserTraceCollector.record(records)));
+      ),
+    );
 
     if (otlpTracesUrl === undefined) {
       return HttpServerResponse.empty({ status: 204 });

apps/server/src/observability/TraceRecord.ts

@@ -147,13 +147,18 @@ export function decodeOtlpTraceRecords(
     const resourceAttributes = decodeAttributes(resourceSpan.resource?.attributes ?? []);
 
     for (const scopeSpan of resourceSpan.scopeSpans) {
+      const scope = scopeSpan.scope as {
+        name?: string;
+        version?: string;
+        attributes?: ReadonlyArray<OtlpResource.KeyValue>;
+      };
       for (const span of scopeSpan.spans) {
         records.push(
           otlpSpanToTraceRecord({
             resourceAttributes,
-            scopeAttributes: {},
-            scopeName: scopeSpan.scope.name,
-            scopeVersion: undefined,
+            scopeAttributes: decodeAttributes(scope?.attributes ?? []),
+            scopeName: scope?.name,
+            scopeVersion: scope?.version,
             span,
           }),
         );
@@ -184,20 +189,23 @@ function otlpSpanToTraceRecord(input: {
     durationMs:
       Number(parseBigInt(input.span.endTimeUnixNano) - parseBigInt(input.span.startTimeUnixNano)) /
       1_000_000,
-    attributes: decodeAttributes(input.span.attributes),
+    attributes: decodeAttributes(input.span.attributes ?? []),
     resourceAttributes: input.resourceAttributes,
     scope: {
       ...(input.scopeName ? { name: input.scopeName } : {}),
       ...(input.scopeVersion ? { version: input.scopeVersion } : {}),
       attributes: input.scopeAttributes,
     },
-    events: decodeEvents(input.span.events),
-    links: decodeLinks(input.span.links),
+    events: decodeEvents(input.span.events ?? []),
+    links: decodeLinks(input.span.links ?? []),
     status: decodeStatus(input.span.status),
   };
 }
 
-function decodeStatus(input: OtlpSpanStatus): OtlpTraceRecord["status"] {
+function decodeStatus(input: OtlpSpanStatus | undefined): OtlpTraceRecord["status"] {
+  if (input == null) {
+    return undefined;
+  }
   const code = String(input.code);
   const message = input.message;
 
@@ -250,7 +258,7 @@ function decodeValue(input: OtlpResource.AnyValue | null | undefined): unknown {
     return input.boolValue;
   }
   if ("intValue" in input) {
-    return input.intValue;
+    return Number(input.intValue);
   }
   if ("doubleValue" in input) {
     return input.doubleValue;