bitfab 0.38.1 → 0.38.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2816ce4e3bcd11bb1335ba7dac6b36376277d17075cf853d26c9befa231a758b
-  data.tar.gz: 7e923c2efb8dfd38edbdd592972a8f236a3fa81cdfabcbd46b8303ba4160b01e
+  metadata.gz: 28a82b98d8327aead543061c18b95a22b2100f89e0289ffdd6ad85a262e08447
+  data.tar.gz: 18c101e18d509cc2a5fb880210d3d5cfaee0f9311c7521abeaa2716bdeca563f
 SHA512:
-  metadata.gz: 15a2df82260f61733b90da3c110b195c92373c187c3eddce5faa041f44499bb008ec5a14cd27dab22b63e2973540010cc2e2f10fcc2dcd75481405d018a107f6
-  data.tar.gz: 13968f6a9f8d3c88ea2845d0d59e0cc1d31ffadc1054311addeedc1e4ba92d94aea504f0f5d11e9891fd0a233e92d285e635e5d8e85e46ebfdf553cdedc45005
+  metadata.gz: 960e4f390e26e953cb555a1a359fd7e3b505172a74e513fe69f281dc7e1111b03e8ac93451154d632dd225e36cdf33f5c54dc3dc59dbd7379a7af3672f7fb87b
+  data.tar.gz: ac599caf319a0dc2814147faee28efd5940609bdc2200d696db4bcb3581fc72fafe443bb50f65204ffb46eea5fa8f0ff9806dd78c42a8d3599e1429263d2ab71

data/lib/bitfab/client.rb

@@ -8,6 +8,7 @@ require_relative "http_client"
 require_relative "replay"
 require_relative "span_context"
 require_relative "serialize"
+require_relative "timestamp"
 require_relative "warn_once"
 
 module Bitfab
@@ -122,14 +123,15 @@ module Bitfab
     #   traces were captured. Receives (args, kwargs, ctx) where ctx is
     #   { original_trace_id:, original_span_id: } (with deprecated
     #   source_trace_id/source_span_id aliases), and returns [new_args, new_kwargs].
-    # @param mock_override [Hash, Array<Hash>, nil] optional selective mock
-    #   override(s), each a { match:, value: } hash. match is a callable:
+    # @param mock_override [Hash, Proc, Array<Hash, Proc>, nil] optional selective
+    #   mock override(s), as { match:, value: } hashes or global resolvers. match is a callable:
     #   match.call(node) selects spans to substitute (node is
     #   { trace_function_key:, span_name:, type:, original_span_id: }). value is
     #   EITHER a flat value injected directly OR a callable invoked with
     #   { node:, inputs:, kwargs:, get_original_output: }; its result becomes
     #   the span's output (full replacement), so downstream real code runs against it. The
-    #   first matching override wins. Per-call overrides take precedence over
+    #   first matching override that does not return NO_MOCK_OVERRIDE wins.
+    #   Per-call overrides take precedence over
     #   those registered via register_mock_override, and both take precedence
     #   over the base mock strategy. The root span is never overridden.
     # @param db_branch [Boolean, Hash, nil] +true+ or a Hash enables database
@@ -169,10 +171,9 @@ module Bitfab
     # clear_mock_overrides to reset. Per-call replay(mock_override:) overrides
     # take precedence, and both take precedence over the base mock strategy.
     #
-    # Accepts either the (match, value) positional form or the keyword form
-    # (a { match:, value: } hash is also accepted). `match` must be callable;
-    # `value` is either a flat value injected directly or a callable invoked
-    # with the ctx hash.
+    # Accepts the (match, value) positional form, the keyword/hash form, one
+    # global resolver callable, or (trace_function_key, override_or_resolver).
+    # A resolver can return Bitfab::NO_MOCK_OVERRIDE to decline the span.
     #
     # @example keyword form (primary), flat value
     #   client.register_mock_override(
@@ -186,19 +187,43 @@ module Bitfab
     #     ->(ctx) { {label: "refund", inputs: ctx[:inputs]} }
     #   )
     #
-    # @param positional [Array] either (match, value) or a single
-    #   { match:, value: } hash
+    # @param positional [Array] a (match, value) pair, one { match:, value: }
+    #   hash, one global resolver, or a trace function key followed by a
+    #   resolver or override hash
     # @param match [#call, nil] keyword form matcher
     # @param value [Object, #call, nil] keyword form injected value or producer
     # @return [void]
     def register_mock_override(*positional, match: nil, value: VALUE_UNSET)
       if match.nil? && value.equal?(VALUE_UNSET)
-        if positional.length == 1 && positional[0].is_a?(Hash)
+        if positional.length == 2 && positional[0].is_a?(String)
+          trace_function_key, keyed_override = positional
+          if keyed_override.is_a?(Hash) && keyed_override[:match].respond_to?(:call) && keyed_override.key?(:value)
+            keyed_match = keyed_override[:match]
+            @mock_overrides << {
+              match: ->(node) { node[:trace_function_key] == trace_function_key && keyed_match.call(node) },
+              value: keyed_override[:value]
+            }
+            return nil
+          end
+          if keyed_override.respond_to?(:call)
+            @mock_overrides << {
+              match: ->(node) { node[:trace_function_key] == trace_function_key },
+              value: keyed_override
+            }
+            return nil
+          end
+          raise ArgumentError,
+            "register_mock_override(trace_function_key, override) requires " \
+            "a { match:, value: } hash or callable resolver."
+        elsif positional.length == 1 && positional[0].is_a?(Hash)
           override = positional[0]
           match = override[:match]
           # Distinguish an omitted :value from an explicit `value: nil`: the
           # key's presence, not a nil read, is what marks it provided.
           value = override.key?(:value) ? override[:value] : VALUE_UNSET
+        elsif positional.length == 1 && positional[0].respond_to?(:call)
+          @mock_overrides << {match: ->(_) { true }, value: positional[0]}
+          return nil
         elsif positional.length == 2
           match, value = positional
         end
@@ -309,7 +334,7 @@ module Bitfab
         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")
+        started_at = Bitfab.now_iso_timestamp
         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)
@@ -388,7 +413,7 @@ module Bitfab
         finalized = true
 
         begin
-          ended_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
+          ended_at = Bitfab.now_iso_timestamp
 
           send_span(
             trace_function_key:,
@@ -782,8 +807,9 @@ module Bitfab
           type: span_type,
           original_span_id: mock_entry && mock_entry[:source_span_id]
         }
-        override = overrides.find { |o| o[:match].call(node) }
-        if override
+        overrides.each do |override|
+          next unless override[:match].call(node)
+
           value = override[:value]
           # value is EITHER a flat value (injected directly) OR a callable
           # invoked with the ctx hash. The result IS the span's output (full
@@ -791,7 +817,10 @@ module Bitfab
           # override always injects, execute_span short-circuits even when this
           # is nil (nil != MOCK_REPLAY_MISS). To inject a proc as the literal
           # output, wrap it in a callable value.
-          return [value, "override"] unless value.respond_to?(:call)
+          unless value.respond_to?(:call)
+            return [value, "override"] unless value.equal?(NO_MOCK_OVERRIDE)
+            next
+          end
 
           get_original_output = lambda do
             unless mock_entry
@@ -799,7 +828,8 @@ module Bitfab
             end
             resolve_recorded_output(mock_entry, replay_ctx)
           end
-          return [value.call({node:, inputs: args, kwargs:, get_original_output:}), "override"]
+          resolved = value.call({node:, inputs: args, kwargs:, get_original_output:})
+          return [resolved, "override"] unless resolved.equal?(NO_MOCK_OVERRIDE)
         end
       end
 
@@ -860,7 +890,7 @@ module Bitfab
     def send_mocked_span(trace_function_key:, trace_id:, span_id:, parent_span_id:,
       span_name:, span_type:, function_name:, args:, kwargs:, mocked_output:,
       started_at:, test_run_id:, input_source_span_id:, mock_source:)
-      ended_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
+      ended_at = Bitfab.now_iso_timestamp
       send_span(
         trace_function_key:,
         trace_id:,

data/lib/bitfab/mock_override.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 module Bitfab
+  # Return from an override resolver to continue to the next override and then
+  # the replay's base mock strategy.
+  NO_MOCK_OVERRIDE = Object.new.freeze
+
   # Selective mock overrides for replay. Mirrors the TypeScript SDK's
   # mockOverride feature.
   #
@@ -10,8 +14,10 @@ module Bitfab
   # substituted output. This is a third mock mode alongside "run real code" and
   # "replay recorded output" (see MOCK_STRATEGIES in replay.rb).
   #
-  # An override is a (match, value) pair, represented as a symbol-keyed hash
-  # { match:, value: }:
+  # An override is a (match, value) pair represented as { match:, value: }, or
+  # one global resolver invoked for every child span. A resolver can route on
+  # ctx[:node][:trace_function_key] and return Bitfab::NO_MOCK_OVERRIDE to
+  # decline the current span.
   #
   # - match is a callable (proc/lambda): match.call(node) -> boolean. node is a
   #   structural-metadata hash { trace_function_key:, span_name:, type:,
@@ -38,9 +44,8 @@ module Bitfab
   module MockOverride
     module_function
 
-    # Normalize the per-call `mock_override` option (a single override hash, an
-    # array of them, or nil) into an array. First match wins downstream, so
-    # order is preserved.
+    # Normalize the per-call `mock_override` option (an override hash, a global
+    # resolver callable, an array, or nil) into an ordered override array.
     #
     # Each override is validated: it must be a hash with a callable `:match` and
     # must include a `:value` key. A forgotten `:value` raises rather than
@@ -49,12 +54,15 @@ module Bitfab
     # `register_mock_override`, and the Python/TypeScript SDKs, where the per-call
     # override object requires a value.
     #
-    # @param mock_override [Hash, Array<Hash>, nil]
+    # @param mock_override [Hash, Proc, Array<Hash, Proc>, nil]
     # @return [Array<Hash>]
     def normalize(mock_override)
       return [] if mock_override.nil?
 
       overrides = mock_override.is_a?(Array) ? mock_override : [mock_override]
+      overrides = overrides.map do |override|
+        override.respond_to?(:call) ? {match: ->(_) { true }, value: override} : override
+      end
       overrides.each do |override|
         unless override.is_a?(Hash) && override[:match].respond_to?(:call)
           raise ArgumentError,

data/lib/bitfab/span_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "timestamp"
+
 module Bitfab
   # Handle to the current active span, allowing context to be added.
   class CurrentSpan
@@ -171,7 +173,7 @@ module Bitfab
     def create(trace_id, test_run_id: nil, input_source_trace_id: nil)
       @states_mutex.synchronize do
         @states[trace_id] ||= begin
-          started_at = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%3NZ")
+          started_at = Bitfab.now_iso_timestamp
           {
             trace_id:,
             started_at:,

data/lib/bitfab/timestamp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Bitfab
+  @timestamp_mutex = Mutex.new
+  @last_timestamp_us = 0
+
+  def self.now_iso_timestamp
+    wall_clock_us = (Time.now.to_r * 1_000_000).to_i
+    timestamp_us = @timestamp_mutex.synchronize do
+      @last_timestamp_us = [wall_clock_us, @last_timestamp_us + 1].max
+    end
+    Time.at(Rational(timestamp_us, 1_000_000)).utc.strftime("%Y-%m-%dT%H:%M:%S.%6NZ")
+  end
+end

data/lib/bitfab/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.38.1
+  version: 0.38.3
 platform: ruby
 authors:
 - Harvest Team
@@ -153,6 +153,7 @@ files:
 - lib/bitfab/replay_registry.rb
 - lib/bitfab/serialize.rb
 - lib/bitfab/span_context.rb
+- lib/bitfab/timestamp.rb
 - lib/bitfab/traceable.rb
 - lib/bitfab/transport.rb
 - lib/bitfab/version.rb