bitfab 0.74.1 → 0.74.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1def1a5df451e3c7b1afa22248c2c54b2b135f5712eb19a989b41209a8c5622
-  data.tar.gz: 16a9741bbda86c16c78aafec91688d962c9ae58e9b032681a07d7b633497c258
+  metadata.gz: 2533a42fd8e3080a107eb28117106080a950076630082392805c6a29d86ab7d8
+  data.tar.gz: 77cf546b4d9b69b22370e8e8a5b6eec12fff1b8122a4b598b11a0a077953f2ec
 SHA512:
-  metadata.gz: 2be36b8b49c5b7c6d6525364c6f10a24d696eb40d8dae2343bdf1b1017e2f2fd47e6c52d8cdf200b4f1cf22a75fdd0ea41bf217e533090a9a42fa725ee7018a8
-  data.tar.gz: 5a4fe53c914d211714bbd2a31d44af37743edf1007f4599f52c6dfcce9e3bf970d90778588b1ee17267394017ed554752882f63d45a06fa7ce693786b97dc152
+  metadata.gz: cef1f28295d0d4c140bd23b003bb712d460a10fe9225ce730526159c083e20a2bf8a423d4641eeffb369b4a6509b0ef86cbfc992ae5d1f5641c91594d0d0868f
+  data.tar.gz: 99f81dace42263bf6e770451cbe266ec5e4a5566ecc559e86984d87f7d82f67c214a610a74f358ec188d2dd52383ef84c4f4e4c4be52cf2ce609f7ec818febcc

data/lib/bitfab/client.rb

@@ -1069,8 +1069,9 @@ module Bitfab
         span_data.merge!(extra_span_data.except(*SimulationPlan::CONTENT_KEYS))
         span_data["content_off_by_simulation_plan"] = true
       else
-        human_inputs, input_dropped = Serialize.serialize_inputs_with_report(args, kwargs)
+        human_inputs, input_dropped, (kept_args, kept_kwargs) = Serialize.serialize_inputs_with_report(args, kwargs)
         human_output, output_dropped = Serialize.serialize_value_with_report(result)
+        kept_result = Serialize.too_large?(output_dropped) ? human_output : result
         dropped = input_dropped + output_dropped
 
         span_data = {
@@ -1081,10 +1082,10 @@ module Bitfab
           "function_name" => function_name
         }
         span_data.merge!(extra_span_data)
-        snapshot = SpanMeta::Snapshot.capture(args, kwargs, result)
+        snapshot = SpanMeta::Snapshot.capture(kept_args, kept_kwargs, kept_result)
         unless snapshot
-          input_meta = SpanMeta.build_input_meta(args, kwargs, human_inputs)
-          output_meta = SpanMeta.build_output_meta(result, human_output)
+          input_meta = SpanMeta.build_input_meta(kept_args, kept_kwargs, human_inputs)
+          output_meta = SpanMeta.build_output_meta(kept_result, human_output)
           span_data["input_meta"] = input_meta if input_meta
           span_data["output_meta"] = output_meta if output_meta
         end

data/lib/bitfab/serialize.rb

@@ -20,6 +20,26 @@ module Bitfab
     # Recursion guard for cyclic graphs and pathologically nested structures.
     MAX_SERIALIZE_DEPTH = 16
 
+    # A running count of bytes the JSON encoding of the walk's output is known
+    # to need (`used`), and of every byte ever counted, including counts later
+    # taken back when a part that raised was stubbed (`charged`). It is also
+    # the catch tag the walk throws to once `used` passes MAX_SERIALIZED_BYTES.
+    Budget = Struct.new(:used, :charged)
+
+    # Once this many bytes have been counted in total, counting stops and the
+    # walk finishes uncounted, so parts that raise and are stubbed over and
+    # over cannot make the walk do unbounded work before the size check.
+    MAX_COUNTED_BYTES = 4 * MAX_SERIALIZED_BYTES
+
+    # String encodings whose bytes JSON writes out one for one (or rejects). In
+    # any other encoding a character can take more bytes than its UTF-8 form,
+    # so only the character count is a safe floor there.
+    BYTE_FOR_BYTE_ENCODINGS = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::BINARY].freeze
+
+    # The dropped entry for a value replaced by a placeholder because it is
+    # past MAX_SERIALIZED_BYTES.
+    TOO_LARGE = "too_large"
+
     module_function
 
     # Serialize a value for JSON storage (human-readable).
@@ -43,22 +63,43 @@ module Bitfab
     # 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.
+    #
+    # The walk counts a lower bound on the JSON size of what it has built so
+    # far and gives up as soon as that passes MAX_SERIALIZED_BYTES, so a value
+    # holding huge arrays or strings is stubbed without first being copied and
+    # encoded in full. The count never exceeds the real size, so a value that
+    # fits is never stubbed; the JSON.dump check afterwards still catches values
+    # whose real size passes the cap while the count does not.
     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]
+      budget = Budget.new(1, 1)
+      result = catch(budget) { serialize_value_inner(value, 0, dropped, budget) }
+      reason = if budget.used > MAX_SERIALIZED_BYTES
+        "too_large_over_#{MAX_SERIALIZED_BYTES}_bytes"
+      elsif oversized?(result)
+        "too_large"
       end
-      [result, dropped]
+      return [result, dropped] unless reason
+
+      dropped << TOO_LARGE
+      [unserializable_stub(value, reason), dropped]
     rescue StandardError, SystemStackError
       [unserializable_stub(value, "unexpected_error"), [class_name(value)]]
     end
 
-    def serialize_value_inner(value, depth, dropped = [])
+    # `budget`, when given, counts the bytes this call's output needs beyond the
+    # one byte its caller already counted for it (every JSON value takes at
+    # least one), and throws to the budget once the total passes the cap.
+    # A hash entry costs its quoted key, a colon, a comma or brace, and the
+    # value's byte. An array or set element costs its byte plus a comma or
+    # bracket; a plain Array or Set is charged for every element before any is
+    # copied, so a huge one is turned away at once. When a part raises, its
+    # stub replaces whatever that part had counted.
+    def serialize_value_inner(value, depth, dropped = [], budget = nil)
+      mark = budget&.used
       if depth > MAX_SERIALIZE_DEPTH
         dropped << "max_depth"
-        return "<unserializable: max_depth>"
+        return counted_string(budget, "<unserializable: max_depth>")
       end
 
       case value
@@ -70,47 +111,95 @@ module Bitfab
           value
         else
           dropped << "non_finite_float"
-          "<unserializable: non_finite_float>"
+          counted_string(budget, "<unserializable: non_finite_float>")
         end
-      when nil, true, false, Integer, String
+      when nil, true, false, Integer
         value
+      when String
+        counted_string(budget, value)
       when Hash
-        value.each_with_object({}) do |(k, v), acc|
-          acc[safe_to_s(k)] = serialize_value_inner(v, depth + 1, dropped)
+        serialize_hash_inner(value, depth, dropped, budget)
+      when Array, Set
+        plain = value.instance_of?(Array) || value.instance_of?(Set)
+        charge(budget, 2 * value.size) if plain
+        value.map do |v|
+          charge(budget, 2) unless plain
+          serialize_value_inner(v, depth + 1, dropped, budget)
         end
-      when Array
-        value.map { |v| serialize_value_inner(v, depth + 1, dropped) }
-      when Set
-        value.map { |v| serialize_value_inner(v, depth + 1, dropped) }
       when Time, DateTime
-        safely_call(value, "iso8601", 3) { safe_to_s(value) }
+        counted_string(budget, safely_call(value, "iso8601", 3) { safe_to_s(value) })
       when Date
-        safe_to_s(value)
+        counted_string(budget, safe_to_s(value))
       when Symbol
-        value.to_s
+        counted_string(budget, value.to_s)
       else
         if value.respond_to?(:to_h)
           h = safely_call(value, "to_h") do
             dropped << class_name(value)
-            return unserializable_stub(value, "to_h_raised")
+            return counted_string(budget, unserializable_stub(value, "to_h_raised"))
           end
-          serialize_value_inner(h, depth + 1, dropped)
+          serialize_value_inner(h, depth + 1, dropped, budget)
         elsif value.respond_to?(:to_a)
           a = safely_call(value, "to_a") do
             dropped << class_name(value)
-            return unserializable_stub(value, "to_a_raised")
+            return counted_string(budget, unserializable_stub(value, "to_a_raised"))
           end
-          serialize_value_inner(a, depth + 1, dropped)
+          serialize_value_inner(a, depth + 1, dropped, budget)
         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)
+          counted_string(budget, safe_to_s(value))
         end
       end
     rescue StandardError, SystemStackError
       dropped << class_name(value)
-      unserializable_stub(value, "inner_error")
+      budget.used = mark if budget
+      counted_string(budget, unserializable_stub(value, "inner_error"))
+    end
+
+    # Serialize a hash's entries into a plain Hash keyed by each key's string.
+    # Keys that stringify alike (such as "data" and :data) share one output
+    # key holding the last of their values, so each output key is counted
+    # once, only the value that is kept is walked, and the key keeps the place
+    # of its first occurrence.
+    def serialize_hash_inner(hash, depth, dropped, budget)
+      entries = []
+      last_index = {}
+      hash.each do |k, v|
+        key = safe_to_s(k)
+        charge(budget, string_floor(key) + 5) unless last_index.key?(key)
+        last_index[key] = entries.size
+        entries << [key, v]
+      end
+      entries.each_with_index.with_object({}) do |((key, v), index), acc|
+        acc[key] = (last_index[key] == index) ? serialize_value_inner(v, depth + 1, dropped, budget) : nil
+      end
+    end
+
+    # Add `bytes` to the running count and stop the walk once it passes the cap.
+    def charge(budget, bytes)
+      return unless budget && budget.charged <= MAX_COUNTED_BYTES
+
+      budget.used += bytes
+      budget.charged += bytes
+      throw budget if budget.used > MAX_SERIALIZED_BYTES
+    end
+
+    # Charge for a string the walk emits (its quotes beyond the byte the caller
+    # counted) and return it.
+    def counted_string(budget, str)
+      charge(budget, string_floor(str) + 1)
+      str
+    end
+
+    # The fewest bytes JSON can write for the characters of `str`, quotes
+    # aside. A String subclass may encode itself through its own to_json, so it
+    # counts as nothing.
+    def string_floor(str)
+      return 0 unless str.instance_of?(String)
+
+      BYTE_FOR_BYTE_ENCODINGS.include?(str.encoding) ? str.bytesize : str.length
     end
 
     # Call `value.<method>` and return the result, or yield to the fallback
@@ -153,23 +242,42 @@ module Bitfab
     end
 
     # Like serialize_inputs, but also returns the accumulated dropped list so the
-    # send boundary can mark a lossy capture non-replayable.
+    # send boundary can mark a lossy capture non-replayable. The third element
+    # is [args, kwargs] with every value past MAX_SERIALIZED_BYTES swapped for
+    # its placeholder (the originals when none is), so the type-preserving
+    # capture never copies a value the readable capture already gave up on.
     def serialize_inputs_with_report(args, kwargs = {})
       dropped = []
-      serialized = args.map do |arg|
+      kept_args = args
+      serialized = args.each_with_index.map do |arg, index|
         result, arg_dropped = serialize_value_with_report(arg)
         dropped.concat(arg_dropped)
+        if too_large?(arg_dropped)
+          kept_args = kept_args.dup if kept_args.equal?(args)
+          kept_args[index] = result
+        end
         result
       end
+      kept_kwargs = kwargs
       unless kwargs.empty?
         kw = kwargs.each_with_object({}) do |(k, v), acc|
           result, v_dropped = serialize_value_with_report(v)
           dropped.concat(v_dropped)
+          if too_large?(v_dropped)
+            kept_kwargs = kept_kwargs.dup if kept_kwargs.equal?(kwargs)
+            kept_kwargs[k] = result
+          end
           acc[safe_to_s(k)] = result
         end
         serialized << kw
       end
-      [serialized, dropped]
+      [serialized, dropped, [kept_args, kept_kwargs]]
+    end
+
+    # Whether a dropped list from serialize_value_with_report means the value
+    # itself was replaced by a placeholder for being past MAX_SERIALIZED_BYTES.
+    def too_large?(dropped)
+      dropped.include?(TOO_LARGE)
     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.74.1"
+  VERSION = "0.74.2"
 end

metadata

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