trailblazer-developer 0.0.27 → 0.1.0

data/lib/trailblazer/developer/trace/present.rb

@@ -2,7 +2,7 @@ require "hirb"
 
 module Trailblazer::Developer
   module Trace
-    module Present
+    module Present # DISCUSS: rename to Debugger?
       module_function
 
       # @private
@@ -12,33 +12,65 @@ module Trailblazer::Developer
 
       # Returns the console output string.
       # @private
-      def render(debugger_nodes, renderer: method(:default_renderer), **options_for_renderer)
-        nodes = debugger_nodes.collect do |debugger_node|
-          renderer.(debugger_node: debugger_node, tree: debugger_nodes, **options_for_renderer)
+      def render(debugger_trace:, renderer: method(:default_renderer), **options_for_renderer)
+        nodes = debugger_trace.to_a.collect do |debugger_node|
+          renderer.(debugger_node: debugger_node, debugger_trace: debugger_trace, **options_for_renderer)
         end
 
         Hirb::Console.format_output(nodes, class: :tree, type: :directory, multi_line_nodes: true)
       end
 
-      # Entry point for rendering a Stack as a "tree branch" the way we do it in {#wtf?}.
-      def call(stack, render_method: method(:render), node_options: {}, **options)
+      # Entry point for rendering a {Trace::Stack}.
+      # Used in `#wtf?`.
+      def call(stack, render_method: method(:render), **options, &block)
+        deprecate_node_options!(**options) # TODO: remove in 0.2.0.
+
+        # Build a generic array of {Trace::Node}s.
+        trace_nodes = Trace.build_nodes(stack.to_a)
+
         # The top activity doesn't have an ID, hence we need to compute a default label.
-        # TODO: maybe we should deep-merge here.
-        captured_input_for_top_activity = stack.to_a[0]
-
-        top_activity_options = {
-          # we can pass particular label "hints".
-          captured_input_for_top_activity => {
-            # label: %{#{captured_input_for_top_activity.task.superclass} (anonymous)},
-            label: captured_input_for_top_activity.task.inspect,
-          },
+        top_activity_trace_node = trace_nodes[0]
+
+        build_options = {
+          node_options: {
+            # we can pass particular label "hints".
+            top_activity_trace_node => {
+              # label: %{#{top_activity_trace_node.task.superclass} (anonymous)},
+              label: top_activity_trace_node.task.inspect,
+            },
+          }
         }
 
-        node_options = top_activity_options.merge(node_options)
+        build_options = build_options.merge(options) # since we only have {:node_options} in {build_options}, we can safely merge here.
+
+        # specific rendering.
+        options_from_block = block_given? ? block.call(trace_nodes: trace_nodes, stack: stack, **build_options) : {}
+
+        build_options = merge_local_options(options_from_block, build_options)
+
+        # currently, we agree on using a Debugger::Node list as the presentation data structure.
+        debugger_trace = Debugger::Trace.build(stack, trace_nodes, **build_options)
 
-        debugger_nodes = Debugger::Node.build_for_stack(stack, node_options: node_options, **options) # currently, we agree on using a Debugger::Node list as the presentation data structure.
+        return render_method.(debugger_trace: debugger_trace, **build_options)
+      end
+
+      def deprecate_node_options!(node_options: nil, **) # TODO: remove in 0.2.0.
+        return unless node_options
+
+        raise "[Trailblazer] The `:node_options` option for `Trace::Present` is deprecated.
+  Please use the block style as described here: https://trailblazer.to/2.1/docs/internals.html#internals-developer-trace-present"
+      end
+
+      # @private
+      def merge_local_options(options, local_options)
+        merged_hash = options.collect do |key, value|
+          [
+            key,
+            value.is_a?(Hash) ? local_options.fetch(key, {}).merge(value) : value # options are winning over local_options[key]
+          ]
+        end.to_h
 
-        return render_method.(debugger_nodes, **options)
+        local_options.merge(merged_hash)
       end
     end # Present
   end

data/lib/trailblazer/developer/trace/snapshot/value.rb

@@ -0,0 +1,39 @@
+module Trailblazer::Developer
+  module Trace
+    class Snapshot
+      # {Value} serializes the variable value using with custom logic, e.g. {value.inspect}.
+      # A series of matchers decide which snapshooter is used.
+      class Value
+        def initialize(matchers)
+          @matchers = matchers
+        end
+
+        # DISCUSS: this could be a compiled pattern matching `case/in` block here.
+        def call(name, value, **options)
+          @matchers.each do |matcher, inspect_method|
+            if matcher.(name, value, **options)
+              return inspect_method.(name, value, **options)
+            end
+          end
+
+          raise "no matcher found for #{name.inspect}" # TODO: this should never happen.
+        end
+
+        def self.default_variable_inspect(name, value, ctx:)
+          value.inspect
+        end
+
+        def self.build
+          new(
+            [
+              [
+                ->(*) { true }, # matches everything
+                method(:default_variable_inspect)
+              ]
+            ]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/developer/trace/snapshot/versions.rb

@@ -0,0 +1,105 @@
+module Trailblazer::Developer
+  module Trace
+    class Snapshot
+      # Snapshot::Ctx keeps an inspected version of each ctx variable.
+      # We figure out if a variable has changed by using `variable.hash` (works
+      # even with deeply nested structures).
+      #
+      # Key idea here is to have minimum work at operation-runtime. Specifics like
+      # figuring out what has changed can be done when using the debugger.
+      #
+      # By keeping "old" versions, we get three benefits.
+      # 1. We only need to call {inspect} once on a traced variable. Especially
+      #    when variables are complex structures or strings, this dramatically speeds
+      #    up tracing, from same-ish to factor 5!
+      # 2. The content sent to our debugger is much smaller which reduces network load
+      #    and storage space.
+      # 3. Presentation becomes simpler as we "know" what variable has changed.
+      #
+      # Possible problems: when {variable.hash} returns the same key even though the
+      #                    data has changed.
+      #
+      # DISCUSS: speed up by checking mutable, only?
+      # DISCUSS: we currently only use this for testing.
+      # DISCUSS: this has knowledge about {Stack} internals.
+      #
+      # This is for the "rendering" layer.
+      # @private
+      def self.snapshot_ctx_for(snapshot, variable_versions)
+        variable_versions = variable_versions.instance_variable_get(:@variables)
+
+        snapshot.data[:ctx_variable_changeset].collect do |name, hash, has_changed|
+          [
+            name,
+            {
+              value:        variable_versions[name][hash],
+              has_changed:  !!has_changed,
+            }
+          ]
+        end.to_h
+      end
+
+      # A table of all ctx variables, their hashes and serialized values.
+      #
+      #   {:current_user=>
+      #     {3298051090906520533=>"#<TraceTest::User:0x000055b2e3424460 @id=1>",
+      #      3764938782671692590=>"#<TraceTest::User:0x000055b2e33e45b8 @id=2>"},
+      #    :params=>
+      #     {2911818769466875657=>"{:name=>\"Q & I\"}",
+      #      2238394858183550663=>"{:name=>\"Q & I\", :song=>{...}}"},
+      #    :seq=>
+      #     {-105020188158523405=>"[]",
+      #      -2281497291400788995=>"[:authenticate]",
+      #      150926802063554866=>"[:authenticate, :authorize]",
+      #      3339595138798116233=>"[:authenticate, :authorize, :model]",
+      #      -3395325862879242711=>
+      #       "[:authenticate, :authorize, :model, :screw_params!]"},
+      #    :model=>{348183403054247453=>"Object"}}
+      class Versions
+        def initialize
+          @variables = {}
+        end
+
+        # DISCUSS: problem with changeset is, we have to go through variables twice.
+        def changeset_for(ctx, value_snapshooter:)
+          new_versions = []
+
+          changeset_for_snapshot = ctx.collect do |name, value|
+            # DISCUSS: do we have to call that explicitly or does Hash#[] do that for us, anyway?
+            value_hash = value.hash # DISCUSS: does this really always change when a deeply nested object changes?
+
+            if (variable_versions = @variables[name]) && variable_versions.key?(value_hash) # TODO: test {variable: nil} value
+              [name, value_hash, nil] # nil means it's an existing reference.
+            else
+              value_snapshot = value_snapshooter.(name, value, ctx: ctx)
+
+              version = [name, value_hash, value_snapshot]
+
+              new_versions << version
+              version
+            end
+          end
+
+          return changeset_for_snapshot, new_versions
+        end
+
+        def add_changes!(new_versions)
+          new_versions.each do |args|
+            add_variable_version!(*args)
+          end
+        end
+
+        # @private
+        def add_variable_version!(name, hash, value)
+          @variables[name] ||= {}
+
+          @variables[name][hash] = value # i hate mutations.
+        end
+
+        def to_h
+          @variables
+        end
+      end
+    end # Snapshot
+  end
+end

data/lib/trailblazer/developer/trace/snapshot.rb

@@ -0,0 +1,71 @@
+module Trailblazer::Developer
+  module Trace
+    # WARNING:  the interfaces here are subject to change, we're still experimenting
+    #           with the architecture of tracing, and a healthy balance of performance/memory
+    #           and clean design.
+    # A Snapshot comprises of data captured before of after a "step". This usually
+    # includes a ctx snapshot, variable versions and a returned signal for after-step
+    # snapshots.
+    #
+    # Note that {Before} and {After} are generic concepts know to Trace::Present and Debugger.
+    #
+    # Snapshot::After{
+    #   signal: <End.Success>
+    #   ctx_snapshot: Snapshot::Ctx{
+    #     variable_versions: [:current_user, 0], [:model, 0]
+    #   }
+    # }
+    class Snapshot < Struct.new(:task, :activity, :data)
+      Before  = Class.new(Snapshot)
+      After   = Class.new(Snapshot)
+
+      # This is called from {Trace.capture_args} and {Trace.capture_return} in the taskWrap.
+      def self.call(ctx_snapshooter, wrap_config, ((ctx, flow_options), circuit_options))
+        # DISCUSS: grab the {snapshooter} here from flow_options, instead of in Trace.capture_args?
+        changeset, new_versions = ctx_snapshooter.call(wrap_config, [[ctx, flow_options], circuit_options])
+
+        snapshot = new( # either Before or After.
+          wrap_config[:task],
+          circuit_options[:activity],
+          changeset
+        ).freeze
+
+        return snapshot, new_versions
+      end
+
+      # Serialize all ctx variables before {call_task}.
+      # This is run just before {call_task}, after In().
+      def self.before_snapshooter(wrap_ctx, ((ctx, flow_options), _))
+        changeset, new_versions = snapshot_for(ctx, **flow_options)
+
+        data = {
+          ctx_variable_changeset: changeset,
+        }
+
+        return data, new_versions
+      end
+
+      # Serialize all ctx variables at the very end of taskWrap, after Out().
+      def self.after_snapshooter(wrap_ctx, _)
+        snapshot_before             = wrap_ctx[:snapshot_before]
+        returned_ctx, flow_options  = wrap_ctx[:return_args]
+
+        changeset, new_versions = snapshot_for(returned_ctx, **flow_options)
+
+        data = {
+          ctx_variable_changeset: changeset,
+          signal:                 wrap_ctx[:return_signal],
+          snapshot_before:        snapshot_before, # add this so we know who belongs together.
+        }
+
+        return data, new_versions
+      end
+
+      def self.snapshot_for(ctx, value_snapshooter:, stack:, **)
+        variable_versions = stack.variable_versions
+
+        variable_versions.changeset_for(ctx, value_snapshooter: value_snapshooter) # return {changeset, new_versions}
+      end
+    end
+  end
+end

data/lib/trailblazer/developer/trace/stack.rb

@@ -3,17 +3,30 @@ module Trailblazer
     module Trace
       # The stack is a linear one-dimensional array. Per traced task two {Trace::Captured}
       # elements get pushed onto it (unless there's an Exception).
+      #
+      # The Stack object maintains the snapshots and the variable versions. It should probably
+      # be named "Trace" :D
+      # It is by design coupled to both Snapshot and Ctx::Versions.
       class Stack
-        def initialize(captureds=[])
-          @stack = captureds
+        def initialize(snapshots = [], variable_versions = Snapshot::Versions.new)
+          @snapshots          = snapshots
+          @variable_versions  = variable_versions # DISCUSS: I dislike the coupling here to Stack, but introducting another object comprised of Stack and VariableVersions seems overkill.
         end
 
-        def <<(captured)
-          @stack << captured
+        attr_reader :variable_versions # TODO: the accessor sucks. But I guess to_h[:variable_versions] is slower.
+
+        def add!(snapshot, new_variable_versions)
+          # variable_versions is mutated in the snapshooter, that's
+          # why we don't have to re-set it here. I'm not a huge fan of mutating it
+          # in a deeply nested scenario but everything else we played with added huge amounts
+          # or runtime code.
+          @variable_versions.add_changes!(new_variable_versions)
+
+          @snapshots << snapshot
         end
 
         def to_a
-          @stack
+          @snapshots
         end
       end # Stack
     end

data/lib/trailblazer/developer/trace.rb

@@ -1,10 +1,11 @@
 module Trailblazer::Developer
   module Trace
-
     class << self
-      # Public entry point to activate tracing when running {activity}.
+      # Public entry point to run an activity with tracing.
+      # It returns the accumulated stack of Snapshots, along with the original return values.
+      # Note that {Trace.invoke} does not do any rendering.
       def call(activity, (ctx, flow_options), **circuit_options)
-        activity, (ctx, flow_options), circuit_options = Trace.arguments_for_call( activity, [ctx, flow_options], **circuit_options ) # only run once for the entire circuit!
+        activity, (ctx, flow_options), circuit_options = Trace.arguments_for_call(activity, [ctx, flow_options], **circuit_options) # only run once for the entire circuit!
 
         signal, (ctx, flow_options) = Trailblazer::Activity::TaskWrap.invoke(activity, [ctx, flow_options], **circuit_options)
 
@@ -15,9 +16,10 @@ module Trailblazer::Developer
 
       def arguments_for_call(activity, (options, original_flow_options), **original_circuit_options)
         default_flow_options = {
-          stack:                  Trace::Stack.new,
-          input_data_collector:   Trace.method(:default_input_data_collector),
-          output_data_collector:  Trace.method(:default_output_data_collector),
+          stack:              Trace::Stack.new,
+          before_snapshooter: Snapshot.method(:before_snapshooter),
+          after_snapshooter:  Snapshot.method(:after_snapshooter),
+          value_snapshooter:  Trace.value_snapshooter
         }
 
         flow_options = {**default_flow_options, **Hash(original_flow_options)}
@@ -32,79 +34,52 @@ module Trailblazer::Developer
       end
     end
 
+    @value_snapshooter = Trace::Snapshot::Value.build()
+    singleton_class.attr_reader :value_snapshooter # NOTE: this is semi-private.
+
     module_function
-    # Insertions for the trace tasks that capture the arguments just before calling the task,
-    # and before the TaskWrap is finished.
-    #
+
     # @private
     def task_wrap_extensions
-      Trailblazer::Activity::TaskWrap.Extension(
-        [Trace.method(:capture_args),   id: "task_wrap.capture_args",   prepend: "task_wrap.call_task"],
-        [Trace.method(:capture_return), id: "task_wrap.capture_return", append: nil], # append to the very end of tW.
-      )
+      TASK_WRAP_EXTENSION
     end
 
+    # Snapshot::Before and After are a generic concept of Trace, as
+    # they're the interface to Trace::Present, WTF, and Debugger.
+
     # It's important to understand that {flow[:stack]} is mutated by design. This is needed so
     # in case of exceptions we still have a "global" trace - unfortunately Ruby doesn't allow
     # us a better way.
     # taskWrap step to capture incoming arguments of a step.
-    def capture_args(wrap_config, ((ctx, flow), circuit_options))
-      original_args = [[ctx, flow], circuit_options]
+    #
+    # Note that we save the created {Snapshot::Before} in the wrap_ctx.
+    def capture_args(wrap_config, original_args)
+      flow_options = original_args[0][1]
 
-      captured_input = Captured(Captured::Input, flow[:input_data_collector], wrap_config, original_args)
+      snapshot, new_versions = Snapshot::Before.(flow_options[:before_snapshooter], wrap_config, original_args)
 
-      flow[:stack] << captured_input
+      # We try to be generic here in the taskWrap snapshooting code, where details happen in Snapshot::Before/After and Stack#add!.
+      flow_options[:stack].add!(snapshot, new_versions)
 
-      return wrap_config, original_args
+      return wrap_config.merge(snapshot_before: snapshot), original_args
     end
 
     # taskWrap step to capture outgoing arguments from a step.
-    def capture_return(wrap_config, ((ctx, flow), circuit_options))
-      original_args = [[ctx, flow], circuit_options]
+    def capture_return(wrap_config, ((ctx, flow_options), circuit_options))
+      original_args = [[ctx, flow_options], circuit_options]
 
-      captured_output = Captured(Captured::Output, flow[:output_data_collector], wrap_config, original_args)
+      snapshot, new_versions = Snapshot::After.(flow_options[:after_snapshooter], wrap_config, original_args)
 
-      flow[:stack] << captured_output
+      flow_options[:stack].add!(snapshot, new_versions)
 
       return wrap_config, original_args
     end
 
-    def Captured(captured_class, data_collector, wrap_config, ((ctx, flow), circuit_options))
-      collected_data = data_collector.call(wrap_config, [[ctx, flow], circuit_options])
-
-      captured_class.new( # either Input or Output
-        wrap_config[:task],
-        circuit_options[:activity],
-        collected_data
-      ).freeze
-    end
-
-    # Called in {#Captured}.
-    # DISCUSS: this is where to start for a new {Inspector} implementation.
-    def default_input_data_collector(wrap_config, ((ctx, _), _)) # DISCUSS: would it be faster to access ctx via {original_args[0][0]}?
-      # mutable, old_ctx = ctx.decompose
-      # mutable, old_ctx = ctx, nil
-
-      {
-        # ctx: ctx.to_h.freeze,
-        ctx_snapshot: ctx.to_h.collect { |k,v| [k, v.inspect] }.to_h,
-      } # TODO: proper snapshot!
-    end
-
-    # Called in {#Captured}.
-    def default_output_data_collector(wrap_config, ((ctx, _), _))
-      returned_ctx, _ = wrap_config[:return_args]
-
-      # FIXME: snapshot!
-      {
-        # ctx: ctx.to_h.freeze,
-        ctx_snapshot: returned_ctx.to_h.collect { |k,v| [k, v.inspect] }.to_h,
-        signal: wrap_config[:return_signal]
-      }
-    end
-
-    Captured         = Struct.new(:task, :activity, :data)
-    Captured::Input  = Class.new(Captured)
-    Captured::Output = Class.new(Captured)
+    # Insertions for the trace tasks that capture the arguments just before calling the task,
+    # and before the TaskWrap is finished.
+    TASK_WRAP_EXTENSION = Trailblazer::Activity::TaskWrap.Extension(
+      [Trace.method(:capture_args),   id: "task_wrap.capture_args",   prepend: "task_wrap.call_task"],
+      [Trace.method(:capture_return), id: "task_wrap.capture_return", append: nil], # append to the very end of tW.
+    )
   end
 end

data/lib/trailblazer/developer/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Developer
-      VERSION = "0.0.27"
+      VERSION = "0.1.0"
     end
   end
 end

data/lib/trailblazer/developer/wtf/renderer.rb

@@ -14,21 +14,21 @@ module Trailblazer::Developer
 
       module_function
 
-      # {options} can be {style: {#<Captured::Input> => [:red, :bold]}}
-      def call(tree:, debugger_node:, style: {}, **options)
-        label = styled_label(tree, debugger_node, style: style, **options)
+      # {options} can be {style: {#<Debugger::Node> => [:red, :bold]}}
+      def call(debugger_trace:, debugger_node:, style: {}, **options)
+        label = styled_label(debugger_trace, debugger_node, style: style, **options)
 
         [debugger_node.level, label]
       end
 
-      def styled_label(tree, debugger_node, color_map:, **options)
+      def styled_label(debugger_trace, debugger_node, color_map:, **options)
         label = apply_style(debugger_node.label, debugger_node, **options)
 
-        %{#{fmt(label, color_map[ signal_of(debugger_node) ])}}
+        %{#{fmt(label, color_map[signal_of(debugger_node)])}}
       end
 
       def apply_style(label, debugger_node, style:, **)
-        return label unless styles = style[debugger_node.captured_input]
+        return label unless styles = style[debugger_node.trace_node]
 
         styles.each { |s| label = fmt(label, s) }
         label
@@ -42,8 +42,8 @@ module Trailblazer::Developer
         String.send(style, line)
       end
 
-      def signal_of(task_node)
-        entity_signal = task_node.captured_output.data[:signal]
+      def signal_of(debugger_node)
+        entity_signal = debugger_node.incomplete? ? nil : debugger_node.snapshot_after.data[:signal]
         entity_klass = entity_signal.is_a?(Class) ? entity_signal : entity_signal.class
 
         SIGNALS_MAP[entity_klass.name.to_sym]

data/lib/trailblazer/developer/wtf.rb

@@ -16,62 +16,62 @@ module Trailblazer::Developer
     # This allows to display the trace even when an exception happened
     def invoke(activity, (ctx, flow_options), present_options: {}, **circuit_options)
       flow_options ||= {}
+      local_present_options_block = ->(*) { {} }
 
       stack = Trace::Stack.new # unfortunately, we need this mutable object before things break.
+      raise_exception = false
+
+      begin
+        complete_stack, signal, (ctx, flow_options) = Trace.invoke(
+          activity,
+          [ctx, flow_options.merge(stack: stack)],
+          **circuit_options
+        )
+      rescue
+        raise_exception = $! # TODO: will this show the very same stacktrace?
+
+        exception_source  = Exception.find_exception_source(stack, $!)
+        complete_stack    = stack
+
+        local_present_options_block = ->(trace_nodes:, **) {
+          exception_source_node = trace_nodes.reverse.find do |trace_node|
+            trace_node.snapshot_after == exception_source || trace_node.snapshot_before == exception_source
+          end
 
-      complete_stack, signal, (ctx, flow_options) = Trace.invoke(
-        activity,
-        [ctx, flow_options.merge(stack: stack)],
-        **circuit_options
-      )
-
-      return signal, [ctx, flow_options], circuit_options
-
-    ensure
-      # incomplete_stack = flow_options[:stack]
-      incomplete_stack = stack
-
-        # in 99%, exception_source is a {Captured::Input}.
-      exception_source = incomplete_stack.to_a.last  # DISCUSS: in most cases, this is where the problem has happened.
-                                                #   However, what if an error happens in, say, an input filter? TODO: test this
-
-      complete_stack = Exception::Stack.complete(incomplete_stack) # TODO: only in case of exception!
-
-      puts Trace::Present.(
+          {
+            # we can hand in options per node, identified by their captured_input part.
+            node_options: {
+              exception_source_node => {data: {exception_source: true}}, # goes to {Debugger::Node.build}
+            },
+            style: {
+              exception_source_node => [:red, :bold]
+            },
+          }
+        }
+      end
+
+      # always render the trace.
+      output, returned_args = Trace::Present.(
         complete_stack,
-        # we can hand in options per node, identified by their captured_input part.
-        node_options: {
-          exception_source => {data: {exception_source: true}}, # goes to {Debugger::Node.build}
-        },
-
         renderer:   Wtf::Renderer,
-        color_map:  Wtf::Renderer::DEFAULT_COLOR_MAP.merge( flow_options[:color_map] || {} ),
-        style: {exception_source => [:red, :bold]},
-        **present_options, # TODO: test.
+        color_map:  Wtf::Renderer::DEFAULT_COLOR_MAP.merge(flow_options[:color_map] || {}),
+        activity:   activity,
+        **present_options,
+        &local_present_options_block
       )
-    end
-
-    module Exception
-      # When an exception occurs the Stack instance is incomplete - it is missing Captured::Output instances
-      # for Inputs still open. This method adds the missing elements so the Trace::Tree algorithm doesn't crash.
-      module Stack
-        def self.complete(incomplete_stack)
-          processed = []
 
-          incomplete_stack.to_a.each do |captured|
-            if captured.is_a?(Trace::Captured::Input)
-              processed << captured
-            else
-              processed.pop
-            end
-          end
+      puts output
 
-          missing_captured = processed.reverse.collect { |captured| Trace::Captured::Output.new(captured.task, captured.activity, {}) }
-
-          Trace::Stack.new(incomplete_stack.to_a + missing_captured)
-        end
-      end # Stack
+      raise raise_exception if raise_exception
+      return signal, [ctx, flow_options], circuit_options, output, returned_args
+    end
 
+    module Exception
+      def self.find_exception_source(stack, exception)
+        # in 99%, exception_source is a {Snapshot::Before}.
+        exception_source = stack.to_a.last  # DISCUSS: in most cases, this is where the problem has happened.
+                                                  #   However, what if an error happens in, say, an input filter? TODO: test this
+      end
     end
   end
 end

data/lib/trailblazer/developer.rb

@@ -9,13 +9,19 @@ end
 require "trailblazer/activity"
 require "trailblazer/developer/wtf"
 require "trailblazer/developer/wtf/renderer"
+require "trailblazer/developer/trace/snapshot"
+require "trailblazer/developer/trace/snapshot/value"
+require "trailblazer/developer/trace/snapshot/versions"
 require "trailblazer/developer/trace"
 require "trailblazer/developer/trace/stack"
-require "trailblazer/developer/trace/tree"
+require "trailblazer/developer/trace/node"
+require "trailblazer/developer/trace/parent_map"
 require "trailblazer/developer/trace/present"
-require "trailblazer/developer/trace/debugger"
+require "trailblazer/developer/debugger"
 require "trailblazer/developer/render/circuit"
 require "trailblazer/developer/render/linear"
 require "trailblazer/developer/render/task_wrap"
 require "trailblazer/developer/introspect" # TODO: might get removed, again.
-require "trailblazer/developer/trace/debugger/normalizer"
+require "trailblazer/developer/debugger/normalizer"
+require "trailblazer/developer/introspect/graph"
+Trailblazer::Developer::Trace::Debugger = Trailblazer::Developer::Debugger # FIXME: deprecate constant!