bitfab 0.15.0 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0e39c364993d34e99e1d7e3c3a878e0fc6fbfe685fcb0335128bfbf7252161b
-  data.tar.gz: 54bcd62faffceac5c0f67f26f5dedbed0057061019d24d1d789f9988fbf0a44a
+  metadata.gz: 0dfedcfce509695e2bb260c885fcfa460aaab8d9c89421379cd7572cd280eb95
+  data.tar.gz: e8aaba21b08b4a53c9f89319e7c7a9d9f0a911f0be657058d80fc84add6e4f6e
 SHA512:
-  metadata.gz: 04cef22ee4135b8c43e1e35f5ead74f5650d9f49e16b818de05980d01a054b145bf4adbad1c9fc3ec01b0e17130e108df666f75bc8bc9bf4666eb23eb9ba7acc
-  data.tar.gz: bb4724aff3d7fc6a9f04e1a923fd5aaabb2e808ef2310ef2c1d51e6a246c296653c1ea85509a92e1a1b927c131074e0907c07623ade5affaa6bab8fd20b2464c
+  metadata.gz: 89851a89aae7ad24ac24d03335e3641b2715c5a841dfd76d302effd8ca07723d41cf0de6103884795fa96337c79671ed9ca5776a5b71c1aa805c3a87621a59b5
+  data.tar.gz: 3fb0c600868f499787e25dc424ce7643ee383f8da1e72fb99ec06a394949fc5ca5f8180e9f40b45791da8f2d4d1b562422bc4921d98643dbefb8c9d03e754893

data/lib/bitfab/client.rb

@@ -53,13 +53,18 @@ module Bitfab
     # @param mock [String] mock strategy for child spans: "none" (default),
     #   "all", or "marked". "all" mocks every child span; "marked" only mocks
     #   spans declared with mock_on_replay: true.
+    # @param adapt_inputs [#call, nil] optional hook to reshape recorded inputs
+    #   onto the method's current signature when its shape changed after the
+    #   traces were captured. Receives (args, kwargs, ctx) where ctx is
+    #   { trace_id:, source_span_id: }, and returns [new_args, new_kwargs].
     # @return [Hash] with :items, :test_run_id, :test_run_url
     def replay(receiver, method_name, trace_function_key:, limit: nil, trace_ids: nil, max_concurrency: 10,
-      code_change_description: nil, code_change_files: nil, experiment_group_id: nil, mock: "none")
+      code_change_description: nil, code_change_files: nil, experiment_group_id: nil, mock: "none",
+      adapt_inputs: nil)
       Replay.run(
         self, receiver, method_name,
         trace_function_key:, limit:, trace_ids:, max_concurrency:,
-        code_change_description:, code_change_files:, experiment_group_id:, mock:
+        code_change_description:, code_change_files:, experiment_group_id:, mock:, adapt_inputs:
       )
     end
 

data/lib/bitfab/replay.rb

@@ -62,8 +62,8 @@ module Bitfab
     # @param method_name [Symbol] the method to replay
     # @param trace_function_key [String] the trace function key for this method
     # @param limit [Integer, nil] maximum number of traces to replay (default: 5).
-    #   Mutually exclusive with trace_ids: an explicit ID list already
-    #   determines how many traces replay, so passing both raises.
+    #   Ignored when trace_ids is passed (with a warning): an explicit ID list
+    #   already determines how many traces replay.
     # @param trace_ids [Array<String>, nil] optional list of trace IDs to replay (max 100)
     # @param max_concurrency [Integer, nil] max threads for parallel replay (default: 10)
     # @param code_change_description [String, nil] optional rationale for the
@@ -75,9 +75,16 @@ module Bitfab
     # @param mock [String] mock strategy for child spans: "none" (default),
     #   "all", or "marked". "all" mocks every child span; "marked" only mocks
     #   spans declared with mock_on_replay: true.
+    # @param adapt_inputs [#call, nil] optional hook to reshape recorded inputs
+    #   onto the method's current signature when its shape changed after the
+    #   traces were captured. Receives (args, kwargs, ctx) where ctx is
+    #   { trace_id:, source_span_id: }, and returns [new_args, new_kwargs]. Runs
+    #   per item inside the same rescue as the method, so a raising adapter sets
+    #   that item's :error rather than crashing the run.
     # @return [Hash] with :items, :test_run_id, :test_run_url
     def run(client, receiver, method_name, trace_function_key:, limit: nil, trace_ids: nil, max_concurrency: 10,
-      code_change_description: nil, code_change_files: nil, experiment_group_id: nil, mock: "none")
+      code_change_description: nil, code_change_files: nil, experiment_group_id: nil, mock: "none",
+      adapt_inputs: nil)
       unless MOCK_STRATEGIES.include?(mock.to_s)
         raise ArgumentError, "Invalid mock strategy '#{mock}'. Must be one of: #{MOCK_STRATEGIES.join(", ")}"
       end
@@ -88,8 +95,8 @@ module Bitfab
         end
       end
       if limit && trace_ids
-        raise ArgumentError,
-          "Pass either limit or trace_ids, not both: an explicit trace ID list already determines how many traces replay."
+        warn "Bitfab: limit is ignored when trace_ids is passed: the explicit trace ID list already " \
+          "determines how many traces replay."
       end
 
       http_client = client.instance_variable_get(:@http_client)
@@ -111,7 +118,8 @@ module Bitfab
       server_items = replay_data["items"] || []
 
       result_items = if server_items.any?
-        process_items(http_client, server_items, receiver, method_name, test_run_id, max_concurrency, mock.to_s)
+        process_items(http_client, server_items, receiver, method_name, test_run_id, max_concurrency, mock.to_s,
+          adapt_inputs)
       else
         []
       end
@@ -183,12 +191,13 @@ module Bitfab
     end
 
     # Process all replay items, optionally in parallel using threads.
-    def process_items(http_client, server_items, receiver, method_name, test_run_id, max_concurrency, mock_strategy)
+    def process_items(http_client, server_items, receiver, method_name, test_run_id, max_concurrency, mock_strategy,
+      adapt_inputs = nil)
       concurrency = max_concurrency || server_items.length
 
       if concurrency <= 1
         server_items.map do |item|
-          process_single_item(http_client, item, receiver, method_name, test_run_id, mock_strategy)
+          process_single_item(http_client, item, receiver, method_name, test_run_id, mock_strategy, adapt_inputs)
         end
       else
         results_mutex = Mutex.new
@@ -202,7 +211,8 @@ module Bitfab
               item, idx = work_mutex.synchronize { work_queue.shift }
               break unless item
 
-              result = process_single_item(http_client, item, receiver, method_name, test_run_id, mock_strategy)
+              result = process_single_item(http_client, item, receiver, method_name, test_run_id, mock_strategy,
+                adapt_inputs)
               results_mutex.synchronize { results[idx] = result }
             end
           end
@@ -219,7 +229,8 @@ module Bitfab
     # deserializing inputs is captured on the returned item's :error rather
     # than propagated, so one bad trace never aborts the whole replay run
     # (mirrors the TypeScript and Python SDKs' per-item rescue).
-    def process_single_item(http_client, server_item, receiver, method_name, test_run_id, mock_strategy)
+    def process_single_item(http_client, server_item, receiver, method_name, test_run_id, mock_strategy,
+      adapt_inputs = nil)
       metrics = extract_server_item_metrics(server_item)
 
       span = http_client.get_external_span(server_item["externalSpanId"])
@@ -231,6 +242,8 @@ module Bitfab
         mock_tree = build_mock_tree(tree["root"] || {})
       end
 
+      adapt_ctx = {trace_id: server_item["traceId"], source_span_id: server_item["externalSpanId"]}
+
       execute_item(
         item_data,
         receiver,
@@ -240,7 +253,9 @@ module Bitfab
         metrics,
         input_source_trace_id: span["externalTraceId"],
         mock_strategy:,
-        mock_tree:
+        mock_tree:,
+        adapt_inputs:,
+        adapt_ctx:
       )
     rescue => e
       warn "Bitfab: replay item for span #{server_item["externalSpanId"]} failed before execution: #{e.message}"
@@ -331,7 +346,7 @@ module Bitfab
 
     # Execute a single replay item: deserialize inputs, call method with replay context.
     def execute_item(item, receiver, method_name, test_run_id, input_source_span_id = nil, metrics = {},
-      input_source_trace_id: nil, mock_strategy: "none", mock_tree: nil)
+      input_source_trace_id: nil, mock_strategy: "none", mock_tree: nil, adapt_inputs: nil, adapt_ctx: nil)
       args, kwargs = Serialize.deserialize_inputs(item)
 
       fn_result = nil
@@ -352,6 +367,13 @@ module Bitfab
         mock_strategy:,
         pending_persistence:
       ) do
+        # Reshape recorded inputs onto the current signature when an adapter is
+        # supplied. Inside the rescue so a raising adapter surfaces on this
+        # item's :error instead of crashing the run; args is reported on :input.
+        if adapt_inputs
+          ctx = adapt_ctx || {trace_id: nil, source_span_id: input_source_span_id}
+          args, kwargs = adapt_inputs.call(args, kwargs, ctx)
+        end
         fn_result = if kwargs.empty?
           receiver.send(method_name, *args)
         else

data/lib/bitfab/version.rb

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

metadata

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