bitfab 0.21.1 → 0.21.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 364e0ec3b3aa00cc47a398872911e18b1a3e5253f4448214da67f9c12af51814
-  data.tar.gz: 482340c71e8d2cb0f8ed92efa7a214278529a670e836e46b6209cc18126f230b
+  metadata.gz: 910352d2c5434b3fae7c3c56ccfea74dc0a22ce35d0cb4d2cb9d463e4ba3660b
+  data.tar.gz: 2e4e07a7447b75404e753f9a2d45350edfbee088ba100aff06031cf477cbc59c
 SHA512:
-  metadata.gz: d9c10548592e02d52a74b96b268bea01d33200c3ff338b61758ec6d54dc2adcf07ca5c442212d464cb53cb86a1aeeccb7466c9ca71ba49810902ff6f5445b0b5
-  data.tar.gz: 3f12de6d0a9eeb5f7c8218d977c4d344a972f762f6c7380e5123d8976032c2215f63337698e4c7d6f18fd669786e4fded0084e0be2ef8fce1e7a696324c2f9b5
+  metadata.gz: 1d197beb80ef3dcd1e57a8aebbe3aafd39ed000cadb0e1098ca71369d69ba53d4e805626f632b3bfdfb5f0cbe36d12e34d589f0b3def09be7e397bb1363e8b5e
+  data.tar.gz: 2f35b7eeba42eb86005e8cb9af3f46654313a84bc375e3c0edbd04e716cd8c511d0d302c2626d5f679b663f3482a24d8ec9b91d9b653fb2da6412aea0da2280b

data/lib/bitfab/client.rb

@@ -425,9 +425,12 @@ module Bitfab
     def send_span(trace_function_key:, trace_id:, span_id:, parent_span_id:,
       span_name:, span_type:, function_name:, contexts:, prompt:, args:, kwargs:, result:, error:,
       started_at:, ended_at:, test_run_id: nil, input_source_span_id: nil)
-      # Human-readable JSON (input/output fields)
-      human_inputs = Serialize.serialize_inputs(args, kwargs)
-      human_output = Serialize.serialize_value(result)
+      # Human-readable JSON (input/output fields). The *_with_report variants
+      # also report what could not be faithfully captured so a lossy span is
+      # marked non-replayable below instead of shipping as if it round-trips.
+      human_inputs, input_dropped = Serialize.serialize_inputs_with_report(args, kwargs)
+      human_output, output_dropped = Serialize.serialize_value_with_report(result)
+      dropped = input_dropped + output_dropped
 
       # Marshal + Base64 for full Ruby-to-Ruby object reconstruction
       raw_input = (args.length == 1 && kwargs.empty?) ? args[0] : {args:, kwargs:}
@@ -469,6 +472,18 @@ module Bitfab
       }
       payload["testRunId"] = test_run_id if test_run_id
 
+      # A value that could only be captured as a placeholder makes the span
+      # non-replayable; record it on the payload's errors (matching the Python
+      # and TypeScript SDKs) instead of shipping the lossy capture silently.
+      unless dropped.empty?
+        names = dropped.uniq.sort.join(", ")
+        payload["errors"] = [{
+          "source" => "sdk",
+          "step" => "serialization_degraded",
+          "error" => "non-replayable: could not faithfully capture #{names}"
+        }]
+      end
+
       @http_client.send_external_span(payload) # Returns the background thread
     end
 

data/lib/bitfab/serialize.rb

@@ -29,28 +29,44 @@ module Bitfab
     #   Without this the wire-side JSON.dump in the http client can produce a
     #   request that times out or gets rejected, leaving a trace with zero spans.
     def serialize_value(value)
-      result = serialize_value_inner(value, 0)
-      return result unless oversized?(result)
+      serialize_value_with_report(value).first
+    end
 
-      unserializable_stub(value, "too_large")
+    # Like serialize_value, but also reports what could not be faithfully
+    # captured. Returns [result, dropped] where dropped lists the class name (or
+    # "max_depth"/"too_large") behind every placeholder the walk had to emit. A
+    # non-empty dropped means the capture is lossy, so the send boundary marks
+    # the span serialization_degraded (non-replayable) instead of shipping it as
+    # if it round-trips. Mirrors the Python/TS SDKs' report serializers.
+    def serialize_value_with_report(value)
+      dropped = []
+      result = serialize_value_inner(value, 0, dropped)
+      if oversized?(result)
+        dropped << "too_large"
+        return [unserializable_stub(value, "too_large"), dropped]
+      end
+      [result, dropped]
     rescue StandardError, SystemStackError
-      unserializable_stub(value, "unexpected_error")
+      [unserializable_stub(value, "unexpected_error"), [class_name(value)]]
     end
 
-    def serialize_value_inner(value, depth)
-      return "<unserializable: max_depth>" if depth > MAX_SERIALIZE_DEPTH
+    def serialize_value_inner(value, depth, dropped = [])
+      if depth > MAX_SERIALIZE_DEPTH
+        dropped << "max_depth"
+        return "<unserializable: max_depth>"
+      end
 
       case value
       when nil, true, false, Integer, Float, String
         value
       when Hash
         value.each_with_object({}) do |(k, v), acc|
-          acc[safe_to_s(k)] = serialize_value_inner(v, depth + 1)
+          acc[safe_to_s(k)] = serialize_value_inner(v, depth + 1, dropped)
         end
       when Array
-        value.map { |v| serialize_value_inner(v, depth + 1) }
+        value.map { |v| serialize_value_inner(v, depth + 1, dropped) }
       when Set
-        value.map { |v| serialize_value_inner(v, depth + 1) }
+        value.map { |v| serialize_value_inner(v, depth + 1, dropped) }
       when Time, DateTime
         safely_call(value, "iso8601", 3) { safe_to_s(value) }
       when Date
@@ -59,16 +75,26 @@ module Bitfab
         value.to_s
       else
         if value.respond_to?(:to_h)
-          h = safely_call(value, "to_h") { return unserializable_stub(value, "to_h_raised") }
-          serialize_value_inner(h, depth + 1)
+          h = safely_call(value, "to_h") do
+            dropped << class_name(value)
+            return unserializable_stub(value, "to_h_raised")
+          end
+          serialize_value_inner(h, depth + 1, dropped)
         elsif value.respond_to?(:to_a)
-          a = safely_call(value, "to_a") { return unserializable_stub(value, "to_a_raised") }
-          serialize_value_inner(a, depth + 1)
+          a = safely_call(value, "to_a") do
+            dropped << class_name(value)
+            return unserializable_stub(value, "to_a_raised")
+          end
+          serialize_value_inner(a, depth + 1, dropped)
         else
+          # An arbitrary object with no structured conversion: stringifying it is
+          # a lossy capture (a repr, not its data), so report it as dropped.
+          dropped << class_name(value)
           safe_to_s(value)
         end
       end
     rescue StandardError, SystemStackError
+      dropped << class_name(value)
       unserializable_stub(value, "inner_error")
     end
 
@@ -108,14 +134,27 @@ module Bitfab
 
     # Serialize function inputs (args + kwargs) for span data (human-readable).
     def serialize_inputs(args, kwargs = {})
-      serialized = args.map { |arg| serialize_value(arg) }
+      serialize_inputs_with_report(args, kwargs).first
+    end
+
+    # Like serialize_inputs, but also returns the accumulated dropped list so the
+    # send boundary can mark a lossy capture non-replayable.
+    def serialize_inputs_with_report(args, kwargs = {})
+      dropped = []
+      serialized = args.map do |arg|
+        result, arg_dropped = serialize_value_with_report(arg)
+        dropped.concat(arg_dropped)
+        result
+      end
       unless kwargs.empty?
         kw = kwargs.each_with_object({}) do |(k, v), acc|
-          acc[safe_to_s(k)] = serialize_value(v)
+          result, v_dropped = serialize_value_with_report(v)
+          dropped.concat(v_dropped)
+          acc[safe_to_s(k)] = result
         end
         serialized << kw
       end
-      serialized
+      [serialized, dropped]
     end
 
     # Marshal a value to a Base64-encoded string for Ruby-to-Ruby reconstruction.

data/lib/bitfab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bitfab
-  VERSION = "0.21.1"
+  VERSION = "0.21.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.21.1
+  version: 0.21.2
 platform: ruby
 authors:
 - Harvest Team