Bug 1990006 - Handle UDF corner cases.

Author: jjjalkanen

sql/mozfun/gecko_trace/build_root_span/udf.sql

@@ -3,6 +3,19 @@ RETURNS JSON
 LANGUAGE js AS r"""
   const spansById = new Map();
   let rootSpanId;
+  if (spans.length === 0) return null;
+
+  // Validation: no null span_ids
+  const nullSpanIds = spans.filter(s => !s.span_id).length;
+  if (nullSpanIds > 0) {
+    throw new Error(`Invalid spans: ${nullSpanIds} span(s) have null or missing span_id`);
+  }
+
+  // Validation: at most one explicit root
+  const explicitRoots = spans.filter(s => !s.parent_span_id).length;
+  if (explicitRoots > 1) {
+    throw new Error(`Invalid span tree: found ${explicitRoots} spans with null parent_span_id, expected at most 1`);
+  }
 
   spans.forEach((span) => {
     const spanId = span.span_id;
@@ -39,6 +52,27 @@ LANGUAGE js AS r"""
     rootSpanId = missingRoots[0].span_id;
   }
 
+  // Cycle detection: verify no circular references
+  const visited = new Set();
+  const visiting = new Set();
+  const hasCycle = (spanId) => {
+    if (visited.has(spanId)) return false;
+    if (visiting.has(spanId)) return true;
+    visiting.add(spanId);
+    const span = spansById.get(spanId);
+    if (span?.childSpans) {
+      for (const child of span.childSpans) {
+        if (hasCycle(child.span_id)) return true;
+      }
+    }
+    visiting.delete(spanId);
+    visited.add(spanId);
+    return false;
+  };
+  if (hasCycle(rootSpanId)) {
+    throw new Error(`Invalid span tree: circular dependency detected`);
+  }
+
   return spansById.get(rootSpanId);
 """;
 
@@ -64,4 +98,29 @@ SELECT
       ),
       "$.span_id"
     )
+  ),
+  -- Test multiple roots validation (should throw)
+  assert.error(
+    () => gecko_trace.build_root_span(
+      [
+        JSON '{"span_id": "root1", "parent_span_id": null}',
+        JSON '{"span_id": "root2", "parent_span_id": null}'
+      ]
+    ),
+    "found 2 spans with null parent_span_id"
+  ),
+  -- Test null span_id validation (should throw)
+  assert.error(
+    () => gecko_trace.build_root_span([JSON '{"span_id": null, "parent_span_id": null}']),
+    "have null or missing span_id"
+  ),
+  -- Test circular dependency detection (should throw)
+  assert.error(
+    () => gecko_trace.build_root_span(
+      [
+        JSON '{"span_id": "a", "parent_span_id": "b"}',
+        JSON '{"span_id": "b", "parent_span_id": "a"}'
+      ]
+    ),
+    "circular dependency"
   );

sql/mozfun/gecko_trace/calculate_signature/udf.sql

@@ -34,30 +34,47 @@ LANGUAGE js AS r"""
 
   const ATTRS_TO_SKIP = {"gecko_process_internal_id": null}
   const hashAttrs = (attrs) => {
+    if (!attrs) return;  // Gracefully skip null/undefined attributes
     for (const [key, value] of Object.entries(attrs)) {
       if (key in ATTRS_TO_SKIP) continue;
-      hash(key);
-      hash(value);
+      hash(String(key));
+      hash(String(value));
     }
   }
 
   const hashEvents = (events) => {
+    if (!events) return;  // Gracefully skip null/undefined events array
     for (const event of events) {
-      hash(event.name);
+      if (!event) continue;  // Skip null events in the array
+      if (event.name) hash(event.name);
       hashAttrs(event.attributes);
     }
   };
 
+  if (rootSpan === null) return null;
   const stack = [rootSpan];
   while (stack.length > 0) {
     const span = stack.pop();
-    hashAttrs(span.resource.attributes);
-    hash(span.scope.name);
-    hash(span.name);
+    if (!span) continue;  // Safety check for null span in stack
+    // Guard on optional resource field per OpenTelemetry spec
+    if (span.resource) {
+      hashAttrs(span.resource.attributes);
+    }
+    // Guard on optional scope field
+    if (span.scope) {
+      hash(span.scope.name);
+    }
+    // Guard on optional name field
+    if (span.name) {
+      hash(span.name);
+    }
     if (span.events) {
-        hashEvents(span.events);
+      hashEvents(span.events);
+    }
+    // Guard on childSpans - may be null, undefined, or missing
+    if (span.childSpans) {
+      stack.push(...span.childSpans);
     }
-    stack.push(...span.childSpans);
   }
 
   return digest;
@@ -80,5 +97,41 @@ SELECT
       JSON '{"span_id": "root", "name": "test", "scope": {"name": "test_scope"}, "resource": {"attributes": {}}, "childSpans": []}'
     )
   ),
-  -- Test that null input returns empty string
-  assert.equals("", gecko_trace.calculate_signature(NULL));
+  -- Test that null input returns null
+  assert.null(gecko_trace.calculate_signature(NULL)),
+  -- Test robustness: missing resource
+  assert.not_null(
+    gecko_trace.calculate_signature(
+      JSON '{"span_id": "root", "name": "test", "scope": {"name": "test"}, "resource": null, "childSpans": []}'
+    )
+  ),
+  -- Test robustness: missing scope
+  assert.not_null(
+    gecko_trace.calculate_signature(
+      JSON '{"span_id": "root", "name": "test", "scope": null, "resource": {"attributes": {}}, "childSpans": []}'
+    )
+  ),
+  -- Test robustness: missing childSpans
+  assert.not_null(
+    gecko_trace.calculate_signature(
+      JSON '{"span_id": "root", "name": "test", "scope": {"name": "test"}, "resource": {"attributes": {}}, "childSpans": null}'
+    )
+  ),
+  -- Test robustness: null event in events array
+  assert.not_null(
+    gecko_trace.calculate_signature(
+      JSON '{"span_id": "root", "name": "test", "scope": {"name": "test"}, "resource": {"attributes": {}}, "events": [null, {"name": "valid_event", "attributes": {}}], "childSpans": []}'
+    )
+  ),
+  -- Test robustness: missing name
+  assert.not_null(
+    gecko_trace.calculate_signature(
+      JSON '{"span_id": "root", "name": null, "scope": {"name": "test"}, "resource": {"attributes": {}}, "childSpans": []}'
+    )
+  ),
+  -- Test robustness: null event attributes
+  assert.not_null(
+    gecko_trace.calculate_signature(
+      JSON '{"span_id": "root", "name": "test", "scope": {"name": "test"}, "resource": {"attributes": {}}, "events": [{"name": "event1", "attributes": null}], "childSpans": []}'
+    )
+  );