bitfab 0.12.0 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e4ca1b81e502de48fe20835b4d072b05736ac5f4ff1a444d683627818648675
-  data.tar.gz: d7120ea5b06e8da151cd9ca26c9549b017458cc2d3b1fa9078ffa512c59d8606
+  metadata.gz: 90f13972943bdfcdd6c5b72859d9ae03b23549577771f0e7d4f8726e2cff9037
+  data.tar.gz: f7c393d995069261d6ddf554727b02b25e6ec37f1f516a0ad01b114f684b5cb9
 SHA512:
-  metadata.gz: b2cbfda78dfd7d726174ace8910f507ea3982d68bb19c402fcaa50b84a20eeddbaf7373932fbec81c93116d8056b41eef876f132aa27913cade2937506299e37
-  data.tar.gz: 41fa08a3eb1a36f21af3358570012625564473eeafd847ab0073c33e012fb341c2b42463a1247e73c929679a1075220c096a4e35a2ac5c7e81151268f3cbbd3c
+  metadata.gz: 2ddfbc335058f37fc3f024b6596d3029dff1601be1243a8f779bbcd7dc899d78f75769c2db8e70894a316649ece042b56f9089fbe39b573bfe40cf313ec2c984
+  data.tar.gz: 0eca0c359e794699587347552b79d608d4ebf6016abef029795a2ffabc475f7d52bc16bcddf32525c7f9a714e7df6386af3c2f9ab6d40d0f8a13c638baf4bf3c

data/lib/bitfab/client.rb

@@ -84,13 +84,12 @@ module Bitfab
       return yield unless @enabled
 
       parent = SpanContext.current
-      trace_id = parent ? parent[:trace_id] : SecureRandom.uuid
+      replay_ctx = ReplayContext.current
+      trace_id = parent ? parent[:trace_id] : (replay_ctx&.dig(:trace_id) || SecureRandom.uuid)
       span_id = SecureRandom.uuid
       parent_span_id = parent&.dig(:span_id)
       is_root_span = parent_span_id.nil?
       started_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
-
-      replay_ctx = ReplayContext.current
       resolved_test_run_id = replay_ctx&.dig(:test_run_id)
       resolved_input_source_span_id = replay_ctx&.dig(:input_source_span_id)
       resolved_input_source_trace_id = replay_ctx&.dig(:input_source_trace_id)

data/lib/bitfab/replay.rb

@@ -22,19 +22,14 @@ module Bitfab
 
     # Execute a block with replay context set on the current thread.
     # The context is automatically cleared when the block completes.
-    #
-    # @param test_run_id [String]
-    # @param input_source_span_id [String, nil]
-    # @param input_source_trace_id [String, nil]
-    # @param mock_tree [Hash{String => Hash}, nil] keyed by "#{key}:#{index}"
-    # @param mock_strategy [String, nil] one of MOCK_STRATEGIES
-    def with_context(test_run_id:, input_source_span_id: nil, input_source_trace_id: nil,
+    def with_context(test_run_id:, input_source_span_id: nil, input_source_trace_id: nil, trace_id: nil,
       mock_tree: nil, mock_strategy: nil)
       previous = Thread.current[REPLAY_CONTEXT_KEY]
       ctx = {
         test_run_id:,
         input_source_span_id:,
-        input_source_trace_id:
+        input_source_trace_id:,
+        trace_id:
       }
       if mock_tree
         ctx[:mock_tree] = mock_tree
@@ -100,9 +95,14 @@ module Bitfab
       Bitfab.flush_traces
 
       begin
-        http_client.complete_replay(test_run_id)
+        complete_response = http_client.complete_replay(test_run_id)
+        trace_id_map = complete_response&.dig("traceIds") || {}
+        result_items.each do |item|
+          item[:trace_id] = trace_id_map[item[:trace_id]]
+        end
       rescue => e
         warn "Bitfab: Failed to complete replay: #{e.message}"
+        result_items.each { |item| item[:trace_id] = nil }
       end
 
       {
@@ -248,11 +248,13 @@ module Bitfab
 
       fn_result = nil
       fn_error = nil
+      sdk_trace_id = SecureRandom.uuid
 
       ReplayContext.with_context(
         test_run_id:,
         input_source_span_id:,
         input_source_trace_id:,
+        trace_id: sdk_trace_id,
         mock_tree:,
         mock_strategy:
       ) do
@@ -272,7 +274,8 @@ module Bitfab
         error: fn_error,
         duration_ms: metrics[:duration_ms],
         tokens: metrics[:tokens],
-        model: metrics[:model]
+        model: metrics[:model],
+        trace_id: sdk_trace_id
       }
     end
   end

data/lib/bitfab/serialize.rb

@@ -6,43 +6,115 @@ require "time"
 
 module Bitfab
   module Serialize
+    # Cap on serialized payload size. Walking arbitrary objects (e.g. an
+    # OpenAI client passed as a span input) can produce hundreds of KB to MB
+    # of useless internal state. Anything beyond this cap is replaced with a
+    # stub so the span still ships and the trace isn't dropped server-side.
+    MAX_SERIALIZED_BYTES = 512_000
+
+    # Recursion guard for cyclic graphs and pathologically nested structures.
+    MAX_SERIALIZE_DEPTH = 16
+
     module_function
 
     # Serialize a value for JSON storage (human-readable).
     # Handles primitives, hashes, arrays, and objects with common conversion methods.
     # Note: We intentionally avoid as_json here because it requires ActiveSupport,
     # and we want to keep the SDK dependency-free (stdlib only).
+    #
+    # Guarantees:
+    # - Never raises. Pathological inputs (objects with raising to_s/to_h,
+    #   cycles, BasicObject subclasses) return a stub string.
+    # - Never returns a value whose JSON encoding exceeds MAX_SERIALIZED_BYTES.
+    #   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)
+
+      unserializable_stub(value, "too_large")
+    rescue StandardError, SystemStackError
+      unserializable_stub(value, "unexpected_error")
+    end
+
+    def serialize_value_inner(value, depth)
+      return "<unserializable: max_depth>" if depth > MAX_SERIALIZE_DEPTH
+
       case value
       when nil, true, false, Integer, Float, String
         value
       when Hash
-        value.transform_keys(&:to_s).transform_values { |v| serialize_value(v) }
+        value.each_with_object({}) do |(k, v), acc|
+          acc[safe_to_s(k)] = serialize_value_inner(v, depth + 1)
+        end
       when Array
-        value.map { |v| serialize_value(v) }
+        value.map { |v| serialize_value_inner(v, depth + 1) }
       when Set
-        value.map { |v| serialize_value(v) }
+        value.map { |v| serialize_value_inner(v, depth + 1) }
       when Time, DateTime
-        value.iso8601(3)
+        safely_call(value, "iso8601", 3) { safe_to_s(value) }
       when Date
-        value.to_s
+        safe_to_s(value)
       when Symbol
         value.to_s
       else
         if value.respond_to?(:to_h)
-          serialize_value(value.to_h)
+          h = safely_call(value, "to_h") { return unserializable_stub(value, "to_h_raised") }
+          serialize_value_inner(h, depth + 1)
         elsif value.respond_to?(:to_a)
-          serialize_value(value.to_a)
+          a = safely_call(value, "to_a") { return unserializable_stub(value, "to_a_raised") }
+          serialize_value_inner(a, depth + 1)
         else
-          value.to_s
+          safe_to_s(value)
         end
       end
+    rescue StandardError, SystemStackError
+      unserializable_stub(value, "inner_error")
+    end
+
+    # Call `value.<method>` and return the result, or yield to the fallback
+    # block if the call raises. Used to harden every call site that invokes a
+    # user-defined method on an arbitrary object.
+    def safely_call(value, method, *args)
+      value.public_send(method, *args)
+    rescue
+      yield
+    end
+
+    def safe_to_s(value)
+      str = value.to_s
+      str.is_a?(String) ? str : "<#{class_name(value)}: to_s returned non-String>"
+    rescue
+      "<#{class_name(value)}: to_s raised>"
+    end
+
+    def class_name(value)
+      value.class.name || "Object"
+    rescue
+      "Object"
+    end
+
+    def unserializable_stub(value, reason)
+      "<unserializable: #{class_name(value)} (#{reason})>"
+    end
+
+    def oversized?(value)
+      JSON.dump(value).bytesize > MAX_SERIALIZED_BYTES
+    rescue
+      # If JSON.dump can't handle it, the wire path can't either, so treat as
+      # oversized to force the stub fallback.
+      true
     end
 
     # Serialize function inputs (args + kwargs) for span data (human-readable).
     def serialize_inputs(args, kwargs = {})
       serialized = args.map { |arg| serialize_value(arg) }
-      serialized << kwargs.transform_keys(&:to_s).transform_values { |v| serialize_value(v) } unless kwargs.empty?
+      unless kwargs.empty?
+        kw = kwargs.each_with_object({}) do |(k, v), acc|
+          acc[safe_to_s(k)] = serialize_value(v)
+        end
+        serialized << kw
+      end
       serialized
     end
 
@@ -51,8 +123,13 @@ module Bitfab
     #
     # @param value [Object] any Ruby value
     # @return [String, nil] Base64-encoded Marshal dump, or nil if marshalling fails
+    #   (objects with non-marshallable members like Proc/IO, or whose marshalled
+    #   size exceeds MAX_SERIALIZED_BYTES).
     def marshal_value(value)
-      Base64.strict_encode64(Marshal.dump(value))
+      dumped = Marshal.dump(value)
+      return nil if dumped.bytesize > MAX_SERIALIZED_BYTES
+
+      Base64.strict_encode64(dumped)
     rescue TypeError, ArgumentError
       # Some objects (Proc, IO, etc.) can't be marshalled
       nil

data/lib/bitfab/version.rb

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

metadata

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