bitfab 0.74.1 → 0.74.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1def1a5df451e3c7b1afa22248c2c54b2b135f5712eb19a989b41209a8c5622
-  data.tar.gz: 16a9741bbda86c16c78aafec91688d962c9ae58e9b032681a07d7b633497c258
+  metadata.gz: e04db08d34f7d195036216aa6f41ee940f81af773924508c2a12da97fbbd1e4a
+  data.tar.gz: 8fd59297c7eeb7e2d053ca2e4722d5b6aea43ae5c96f691a2addf81f0f9452ea
 SHA512:
-  metadata.gz: 2be36b8b49c5b7c6d6525364c6f10a24d696eb40d8dae2343bdf1b1017e2f2fd47e6c52d8cdf200b4f1cf22a75fdd0ea41bf217e533090a9a42fa725ee7018a8
-  data.tar.gz: 5a4fe53c914d211714bbd2a31d44af37743edf1007f4599f52c6dfcce9e3bf970d90778588b1ee17267394017ed554752882f63d45a06fa7ce693786b97dc152
+  metadata.gz: aa1099e23b6af4619238c7b6b94f13e9ad15ead7aa6dcaa7fb5a993b634dd00ab6468c5924bcc717da520fa9f0e96d3d5e82a7ab32656e96885626b07e38c3e2
+  data.tar.gz: a99c779521142a681697cdadd6b031b1f2f181e851c919ec2f8e571dd3eb447eeccb6063380c5ee8ccfc706e420ef1e2fe23bc0fdd2eb5802e5930838372a075

data/lib/bitfab/client.rb

@@ -1021,7 +1021,7 @@ module Bitfab
         "type" => "sdk-function",
         "source" => "ruby-sdk-function",
         "traceFunctionKey" => trace_function_key,
-        "externalTrace" => raw_trace,
+        "rawTrace" => raw_trace,
         "completed" => true
       }
 
@@ -1037,7 +1037,7 @@ module Bitfab
         payload["testRunId"] = trace_state[:experiment_id]
       end
 
-      @http_client.send_external_trace(payload)
+      @http_client.send_trace_payload(payload)
 
       # Clean up trace state
       TraceState.delete(trace_id)
@@ -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
@@ -1145,7 +1146,7 @@ module Bitfab
         }]
       end
 
-      @http_client.send_external_span(payload, declared_node, snapshot)
+      @http_client.send_span_payload(payload, declared_node, snapshot)
     end
 
     # Advance the per-(key, name) call counter when this invocation is a
@@ -1179,10 +1180,6 @@ module Bitfab
     def check_mock_replay(replay_ctx, trace_function_key, span_name, call_index, span_type:, args:, kwargs:, mock_on_replay:)
       mock_entry = replay_ctx[:mock_tree]["#{trace_function_key}:#{span_name}:#{call_index}"]
 
-      # 1) Selective overrides. The matcher runs on structural metadata only;
-      # the recorded output is fetched (lazily, by externalSpanId) only if the
-      # processor actually asks for it via get_original_output, so a pure
-      # synthetic override triggers zero output fetches.
       overrides = replay_ctx[:mock_overrides]
       if overrides&.any?
         node = {
@@ -1242,7 +1239,7 @@ module Bitfab
     # Resolve a mock-tree entry's recorded output. Prefers an inline output when
     # the tree carried one (eager "all", or an older server that ignores
     # includeOutputs and returns outputs); otherwise lazily fetches it by
-    # externalSpanId through the per-item memoized fetcher on the replay
+    # span ID through the per-item memoized fetcher on the replay
     # context, so only the spans actually mocked pull their output.
     #
     # Deserialization is type-preserving when Ruby-side Marshal+Base64 metadata
@@ -1257,9 +1254,9 @@ module Bitfab
       end
 
       fetcher = replay_ctx[:fetch_span_output]
-      external_span_id = mock_entry[:external_span_id]
-      if fetcher && external_span_id
-        return fetcher.call(external_span_id)
+      span_row_id = mock_entry[:span_row_id]
+      if fetcher && span_row_id
+        return fetcher.call(span_row_id)
       end
 
       # No inline output and nothing to lazily fetch. This is a span that never

data/lib/bitfab/http_client.rb

@@ -192,8 +192,8 @@ module Bitfab
       raise last_error
     end
 
-    # Queue an external span on this client's trace transport (fire-and-forget).
-    def send_external_span(payload, declared_node = false, snapshot = nil)
+    # Queue a span payload on this client's trace transport (fire-and-forget).
+    def send_span_payload(payload, declared_node = false, snapshot = nil)
       if (data = payload.dig("rawSpan", "span_data")).is_a?(Hash) && !data.key?("runtime")
         payload = payload.merge("rawSpan" => payload["rawSpan"].merge("span_data" => data.merge("runtime" => ThreadPropagation.runtime)))
       end
@@ -334,11 +334,12 @@ module Bitfab
       request("/api/sdk/replay/start", payload, timeout:)
     end
 
-    # Fetch an external span by ID. Blocking GET request. The replay view keeps
-    # only the input/output serialization fields used by replay.
-    def get_external_span(span_id, replay_view: false)
+    # Fetch a span's raw record by its Bitfab row ID. Blocking GET request.
+    # The replay view keeps only the input/output serialization fields used
+    # by replay.
+    def get_span_raw(span_id, replay_view: false)
       query = replay_view ? "?view=replay" : ""
-      get("/api/sdk/externalSpans/#{span_id}#{query}", timeout: 30)
+      get("/api/sdk/spans/#{span_id}/raw#{query}", timeout: 30)
     end
 
     def get_trace_span(trace_id, id: nil, name: nil, type: nil, occurrence: "last")
@@ -359,19 +360,19 @@ module Bitfab
       get("/api/sdk/spans/#{encoded_span_id}", timeout: 30)["span"]
     end
 
-    # Fetch the span tree rooted at an external span. Blocking GET request.
+    # Fetch the span tree rooted at a span. Blocking GET request.
     # Used by replay when a mock strategy is active so child spans can be
     # matched against their historical outputs.
     #
     # Returns a hash shaped { "root" => SpanTreeNode } where each node has
-    # sourceSpanId, externalSpanId, traceFunctionKey, spanName, type, and
+    # sourceSpanId, spanId, traceFunctionKey, spanName, type, and
     # children. When include_outputs is true each node also carries its recorded
     # output (and optional outputMeta); when false the server omits the output
     # payloads so only the spans actually mocked are fetched later (by
-    # externalSpanId), avoiding dragging down every span's output when only a
+    # spanId), avoiding dragging down every span's output when only a
     # few are mocked.
-    def get_span_tree(external_span_id, include_outputs: true, include_root_output: true)
-      endpoint = "/api/sdk/replay/spanTree/#{external_span_id}"
+    def get_span_tree(span_id, include_outputs: true, include_root_output: true)
+      endpoint = "/api/sdk/replay/spanTree/#{span_id}"
       query = []
       query << "includeOutputs=false" unless include_outputs
       query << "includeRootOutput=false" unless include_root_output
@@ -402,23 +403,23 @@ module Bitfab
       )
     end
 
-    # Queue an external trace on this client's trace transport (fire-and-forget).
-    def send_external_trace(payload)
+    # Queue a trace payload on this client's trace transport (fire-and-forget).
+    def send_trace_payload(payload)
       submit = ->(record) {
         ref = carrier_ref(record)
         if record["completed"] == true && ref
           @trace_completion.close(ref.trace_id, dropped: record["dropped"] == true) do |count|
-            submit_external_trace(record.merge("expectedSpanCount" => count))
+            submit_trace_payload(record.merge("expectedSpanCount" => count))
           end
         else
           @trace_completion.open(ref.trace_id) if ref
-          submit_external_trace(record)
+          submit_trace_payload(record)
         end
       }
       @simulation_plan ? @simulation_plan.send_trace(payload, &submit) : submit.call(payload)
     end
 
-    def submit_external_trace(payload)
+    def submit_trace_payload(payload)
       trace_transport&.submit(
         "external_trace",
         payload.merge("sdkVersion" => VERSION),
@@ -473,7 +474,7 @@ module Bitfab
     def payload_timestamp(payload, field)
       raw = payload.dig("rawSpan", field) if payload["rawSpan"].is_a?(Hash)
       if raw.nil?
-        raw_trace = payload["externalTrace"] || payload["rawTrace"]
+        raw_trace = payload["rawTrace"] || payload["externalTrace"]
         raw = raw_trace[field] if raw_trace.is_a?(Hash)
       end
       return nil unless raw.is_a?(String)
@@ -496,7 +497,7 @@ module Bitfab
     def carrier_ref(payload)
       trace_id = payload["sourceTraceId"]
       unless trace_id.is_a?(String)
-        raw_trace = payload["externalTrace"] || payload["rawTrace"]
+        raw_trace = payload["rawTrace"] || payload["externalTrace"]
         trace_id = raw_trace["id"] if raw_trace.is_a?(Hash)
       end
       return nil unless trace_id.is_a?(String)

data/lib/bitfab/replay.rb

@@ -1144,20 +1144,9 @@ module Bitfab
         )
       end
 
-      span = http_client.get_external_span(original_span_id, replay_view: true)
+      span = http_client.get_span_raw(original_span_id, replay_view: true)
       item_data = extract_span_data(span)
 
-      # Fetch the span tree when the base strategy needs recorded outputs
-      # ("all"/"marked") OR when selective mock overrides are present. Overrides
-      # gate on the same non-root call-counter machinery the tree drives, so
-      # the tree must be fetched for them to fire even under mock: "none".
-      #
-      # Only mock: "all" needs every span's recorded output inline (it mocks
-      # every matched recorded child), so it fetches an eager tree even when
-      # overrides exist.
-      # Non-"all" runs that need a tree ("marked", or "none" with overrides)
-      # fetch it payload-free (includeOutputs=false) and pull each mocked span's
-      # output lazily by externalSpanId, never dragging down unused outputs.
       overrides_present = !mock_overrides.nil? && !mock_overrides.empty?
       include_outputs = mock_strategy == "all"
       mock_tree = nil
@@ -1201,7 +1190,7 @@ module Bitfab
         experiment_id,
         span["id"],
         metrics,
-        input_source_trace_id: span["externalTraceId"],
+        input_source_trace_id: span["traceId"] || span["externalTraceId"],
         selective_replay:,
         mock_strategy:,
         mock_tree:,
@@ -1294,14 +1283,9 @@ module Bitfab
           counter_key = "#{key}:#{name}"
           index = counters[counter_key] || 0
           counters[counter_key] = index + 1
-          # externalSpanId is what the lazy path fetches the recorded output by
-          # when the tree came back payload-free (includeOutputs=false). output
-          # / outputMeta are copied ONLY when the node actually carries them, so
-          # the presence of the :output key distinguishes an inline nil output
-          # from a payload-free entry (mirrors TS's undefined-vs-null check).
           entry = {
             source_span_id: node["sourceSpanId"],
-            external_span_id: node["externalSpanId"]
+            span_row_id: node["spanId"] || node["externalSpanId"]
           }
           entry[:output] = node["output"] if node.key?("output")
           entry[:output_meta] = node["outputMeta"] if node.key?("outputMeta")
@@ -1316,25 +1300,25 @@ module Bitfab
     end
 
     # Build a memoized lazy fetcher for a single replay item. The returned
-    # lambda takes an externalSpanId and returns that span's deserialized
-    # recorded output, fetching it via get_external_span at most once per id
+    # lambda takes a span ID and returns that span's deserialized
+    # recorded output, fetching it via get_span_raw at most once per id
     # (a span read twice - as a base "marked" mock and via an override's
     # get_original_output - fetches once). The cache is per item: each item
     # replays synchronously on its own thread, so no lock is needed.
     def build_span_output_fetcher(http_client)
       cache = {}
-      lambda do |external_span_id|
-        return cache[external_span_id] if cache.key?(external_span_id)
+      lambda do |span_row_id|
+        return cache[span_row_id] if cache.key?(span_row_id)
 
-        span = http_client.get_external_span(external_span_id, replay_view: true)
+        span = http_client.get_span_raw(span_row_id, replay_view: true)
         span_data = (span["rawData"] || {})["span_data"] || {}
         meta = span_data["output_serialized"]
         meta = span_data["output_meta"] if meta.nil? || meta == ""
-        cache[external_span_id] = Serialize.deserialize_output(span_data["output"], meta)
+        cache[span_row_id] = Serialize.deserialize_output(span_data["output"], meta)
       end
     end
 
-    # Extract input/output data from an external span's rawData.
+    # Extract input/output data from a span's rawData.
     def extract_span_data(span)
       raw_data = span["rawData"] || {}
       span_data = raw_data["span_data"] || {}

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/simulation_plan.rb

@@ -198,7 +198,7 @@ module Bitfab
     end
 
     def trace_id(payload)
-      payload["traceId"] || payload["sourceTraceId"] || payload.dig("externalTrace", "id") || payload["id"]
+      payload["traceId"] || payload["sourceTraceId"] || payload.dig("rawTrace", "id") || payload.dig("externalTrace", "id") || payload["id"]
     end
 
     def framework?(payload)

data/lib/bitfab/version.rb

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

data/lib/bitfab.rb

@@ -146,9 +146,6 @@ module Bitfab
       lease = ctx[:db_branch_lease]
       return unless lease
 
-      # Surface the Bitfab trace ID (what the customer sees in the dashboard),
-      # not the external one. Falling back to the external ID keeps replays from
-      # external sources working until that path is fully wired.
       trace_id = ctx[:source_bitfab_trace_id] || ctx[:input_source_trace_id]
       return unless trace_id
 

metadata

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