bitfab 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0e39c364993d34e99e1d7e3c3a878e0fc6fbfe685fcb0335128bfbf7252161b
-  data.tar.gz: 54bcd62faffceac5c0f67f26f5dedbed0057061019d24d1d789f9988fbf0a44a
+  metadata.gz: 3320e43b6f1be704f5ab955161b347d954691c6cdc75f5e57ab01452e8f8dd7f
+  data.tar.gz: 2b8872ef106d63560d6718ab4d2076f6271417fbc56e44581c2e4f5058ff4a00
 SHA512:
-  metadata.gz: 04cef22ee4135b8c43e1e35f5ead74f5650d9f49e16b818de05980d01a054b145bf4adbad1c9fc3ec01b0e17130e108df666f75bc8bc9bf4666eb23eb9ba7acc
-  data.tar.gz: bb4724aff3d7fc6a9f04e1a923fd5aaabb2e808ef2310ef2c1d51e6a246c296653c1ea85509a92e1a1b927c131074e0907c07623ade5affaa6bab8fd20b2464c
+  metadata.gz: f9599b68cfbac6812070bfd05516b1372e607e5cc2214a5e7319ca39b5e22c80390db4b3446e6c136bea2c2a0780e8ffeab5fbb99226e2bf7636ace35a9a72f5
+  data.tar.gz: 98c9855c1d5f3cb4403926820b223733c555696211ab27d0980c06f9f38e01aa02b0e4c2065525c33eed6bd8e60f0136b3a4951a67416051181287b5f7acbc7a

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

@@ -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
@@ -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.0"
 end

metadata

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