bitfab 0.75.1 → 0.75.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fad2341a7e82e22c18faf4809a1807407660eed238b04886b2687e4dc15989b2
-  data.tar.gz: 7a46b9c4935290898decf6f835257d5b8551281eb1ddebb1680128fcd5ac8c74
+  metadata.gz: 5b80995a3476aa0fd9dd0eb926924081189bd6dc85efbdf9fe5ad0a07f375dae
+  data.tar.gz: 409f0f9b9837f142aed5233a6307fb30740f5409955dd0d74af8c9d36e27ebc6
 SHA512:
-  metadata.gz: 82ef99ecba72308fc1e865257f260756cab829bae0167404f50f8317dd0d921446b02f4379f5c254e98f8deb3fb68104afa73075c4081cc9d5a7b7345243611f
-  data.tar.gz: 696fb090a73f51ab3bb9ca07277e89a0529dd3031a8c96bfa581f7c54235ba3205f804df4790e5d83163d635dfa5228f9d0be05e4e37d4c1805fb7271a920732
+  metadata.gz: fe3ae22d0d2da90db167cf4d968cf2fe71bcaba899fa3393ab822a8cc7682961c0fcb8aa9bf842e0630cca46827fbfed433813e1a1b2f0bf191f3766bee708c8
+  data.tar.gz: 4490e80fdac9fbb0288177e158926e46e5c17f16889d11ce1b241579c98616bf144250a59def158ce771831edfaba80c046f9d2d78604b3079d582f495eb86c1

data/lib/bitfab/client.rb

@@ -743,7 +743,7 @@ module Bitfab
           end
         end
       rescue => e
-        error = e.message
+        error = ErrorChain.describe(e)
         complete.call(result, error)
         raise
       end
@@ -944,7 +944,7 @@ module Bitfab
               end
               complete.call(yielded, nil)
             rescue => e
-              complete.call(yielded, e.message)
+              complete.call(yielded, ErrorChain.describe(e))
               raise
             ensure
               SpanContext.stack.pop

data/lib/bitfab/error_chain.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Bitfab
+  # Reads the chain of causes below an exception. A database driver error
+  # usually reaches a traced method wrapped one or two levels down, so
+  # recording only the top message makes a connection timeout read as a broken
+  # query. Spans and replay results carry the deepest cause too.
+  module ErrorChain
+    # How many causes below an exception are followed.
+    MAX_DEPTH = 10
+    CODE_METHODS = %i[code sqlstate errno].freeze
+
+    module_function
+
+    # The causes below `error`, nearest first, stopping at the depth limit or
+    # at a cause already seen.
+    def causes(error)
+      found = []
+      seen = {error.object_id => true}
+      current = error
+      while found.length < MAX_DEPTH
+        cause = current.cause
+        break if cause.nil? || seen[cause.object_id]
+
+        found << cause
+        seen[cause.object_id] = true
+        current = cause
+      end
+      found
+    end
+
+    # The exception's message, followed by the deepest cause's message when it
+    # wraps another exception, e.g. `Failed query: ... (caused by: connection
+    # timeout)`. The cause is left off when the message already contains it.
+    def describe(error)
+      message = error.message
+      deepest = causes(error).last
+      return message if deepest.nil?
+
+      deepest_message = deepest.message.to_s.strip
+      return message if deepest_message.empty? || message.include?(deepest_message)
+
+      "#{message} (caused by: #{deepest_message})"
+    end
+
+    # An exception as a JSON record: type, message, backtrace, the driver's
+    # code when it has one, and its causes nested under `cause` down to the
+    # depth limit. The block adds fields a specific exception type carries.
+    def serialize(error, &extra)
+      serialize_at(error, 1, {}, &extra)
+    end
+
+    # `seen` is created fresh by `serialize` for each top-level call, so one
+    # call never skips a cause another call already recorded.
+    def serialize_at(error, depth, seen, &extra)
+      seen[error.object_id] = true
+      serialized = {type: error.class.name, message: error.message, backtrace: error.backtrace}
+      code = error_code(error)
+      serialized[:code] = code unless code.nil?
+      serialized.merge!(extra.call(error)) if extra
+      cause = error.cause
+      if cause && !seen[cause.object_id] && depth < MAX_DEPTH
+        serialized[:cause] = serialize_at(cause, depth + 1, seen, &extra)
+      end
+      serialized
+    end
+    private_class_method :serialize_at
+
+    def error_code(error)
+      CODE_METHODS.each do |name|
+        next unless error.respond_to?(name)
+
+        value = begin
+          error.public_send(name)
+        rescue
+          nil
+        end
+        return value if value.is_a?(String) || value.is_a?(Integer)
+      end
+      nil
+    end
+  end
+end

data/lib/bitfab/replay.rb

@@ -160,13 +160,9 @@ module Bitfab
     def json_safe(value)
       case value
       when Exception
-        serialized = {type: value.class.name, message: value.message, backtrace: value.backtrace}
-        if value.is_a?(DbBranchReplayError)
-          serialized[:code] = value.code
-          serialized[:original_trace_id] = value.original_trace_id
-          serialized[:cause] = json_safe(value.cause) if value.cause
+        ErrorChain.serialize(value) do |error|
+          error.is_a?(DbBranchReplayError) ? {original_trace_id: error.original_trace_id} : {}
         end
-        serialized
       when Hash
         value.to_h { |key, child| [key, json_safe(child)] }
       when Array
@@ -177,7 +173,7 @@ module Bitfab
     end
 
     def replay_item_error_message(error)
-      return error.message unless error.is_a?(DbBranchReplayError)
+      return ErrorChain.describe(error) unless error.is_a?(DbBranchReplayError)
 
       "Replay requested a database branch for trace #{error.original_trace_id} but it " \
         "could not be resolved (#{error.code}): #{error.message}. The method was not run, " \
@@ -1528,7 +1524,7 @@ module Bitfab
         input: kwargs.empty? ? args : [*args, kwargs],
         result: fn_result,
         original_output: item["output"],
-        error: item_error&.message,
+        error: item_error && ErrorChain.describe(item_error),
         trace_error: fn_error,
         replay_error:,
         duration_ms: replay_duration_ms,

data/lib/bitfab/subtree.rb

@@ -740,7 +740,7 @@ module Bitfab
         return unless entry.is_a?(OpenSpan)
 
         exception = event.raised_exception
-        entry.error = "#{exception.class}: #{exception.message}"
+        entry.error = "#{exception.class}: #{ErrorChain.describe(exception)}"
       end
 
       def clear_rescued_error(event)

data/lib/bitfab/version.rb

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

data/lib/bitfab.rb

@@ -5,6 +5,7 @@ require "json"
 require_relative "bitfab/version"
 require_relative "bitfab/constants"
 require_relative "bitfab/warn_once"
+require_relative "bitfab/error_chain"
 require_relative "bitfab/experiment_id"
 require_relative "bitfab/payload_budget"
 require_relative "bitfab/serialize"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.75.1
+  version: 0.75.2
 platform: ruby
 authors:
 - Harvest Team
@@ -183,6 +183,7 @@ files:
 - lib/bitfab/db_snapshot.rb
 - lib/bitfab/detached_trace.rb
 - lib/bitfab/env.rb
+- lib/bitfab/error_chain.rb
 - lib/bitfab/experiment_id.rb
 - lib/bitfab/experiments.rb
 - lib/bitfab/git_command.rb