trailblazer-developer 0.0.28 → 0.1.0

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.28"
+      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,14 +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!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-developer
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.1.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -131,17 +131,21 @@ files:
 - bin/console
 - bin/setup
 - lib/trailblazer/developer.rb
+- lib/trailblazer/developer/debugger.rb
+- lib/trailblazer/developer/debugger/normalizer.rb
 - lib/trailblazer/developer/introspect.rb
 - lib/trailblazer/developer/introspect/graph.rb
 - lib/trailblazer/developer/render/circuit.rb
 - lib/trailblazer/developer/render/linear.rb
 - lib/trailblazer/developer/render/task_wrap.rb
 - lib/trailblazer/developer/trace.rb
-- lib/trailblazer/developer/trace/debugger.rb
-- lib/trailblazer/developer/trace/debugger/normalizer.rb
+- lib/trailblazer/developer/trace/node.rb
+- lib/trailblazer/developer/trace/parent_map.rb
 - lib/trailblazer/developer/trace/present.rb
+- lib/trailblazer/developer/trace/snapshot.rb
+- lib/trailblazer/developer/trace/snapshot/value.rb
+- lib/trailblazer/developer/trace/snapshot/versions.rb
 - lib/trailblazer/developer/trace/stack.rb
-- lib/trailblazer/developer/trace/tree.rb
 - lib/trailblazer/developer/version.rb
 - lib/trailblazer/developer/wtf.rb
 - lib/trailblazer/developer/wtf/renderer.rb

data/lib/trailblazer/developer/trace/debugger/normalizer.rb

@@ -1,68 +0,0 @@
-module Trailblazer
-  module Developer
-    module Trace
-      module Debugger
-        # @private
-        # Public entry point to add Debugger::Node normalizer steps.
-        def self.add_normalizer_step!(step, id:, normalizer: Normalizer::PIPELINES.last, **options)
-          task = Normalizer.Task(step)
-
-          # We have a TaskWrap::Pipeline (a very simple style of "activity" used for normalizers) and
-          # add another step using the "friendly interface" from {Activity::Adds}.
-          options = {append: nil} unless options.any?
-
-          pipeline_extension = Activity::TaskWrap::Extension.build([task, id: id, **options])
-
-          Normalizer::PIPELINES << pipeline_extension.(normalizer)
-        end
-
-        module Normalizer
-          def self.Task(user_step) # TODO: we could keep this in the {activity} gem.
-            Activity::TaskWrap::Pipeline::TaskAdapter.for_step(user_step, option: false) # we don't need Option as we don't have ciruit_options here, and no {:exec_context}
-          end
-
-          # Default steps for the Debugger::Node options pipeline, following the step-interface.
-          module Default
-            def self.compile_id(ctx, activity:, task:, **)
-              ctx[:compile_id] = Activity::Introspect.Nodes(activity, task: task)[:id]
-            end
-
-            def self.compile_path(ctx, parent_map:, captured_node:, **)
-              ctx[:compile_path] = Trace::Tree::ParentMap.path_for(parent_map, captured_node)
-            end
-
-            def self.runtime_id(ctx, compile_id:, **)
-              ctx[:runtime_id] = compile_id
-            end
-
-            def self.runtime_path(ctx, runtime_id:, compile_path:, **)
-              return ctx[:runtime_path] = compile_path if compile_path.empty? # FIXME: this currently only applies to root.
-
-              ctx[:runtime_path] = compile_path[0..-2] + [runtime_id]
-            end
-
-            def self.label(ctx, label: nil, runtime_id:, **)
-              ctx[:label] = label || runtime_id
-            end
-
-            def self.data(ctx, data: {}, **)
-              ctx[:data] = data
-            end
-          end
-
-          default_steps = {
-            compile_id:       Normalizer.Task(Default.method(:compile_id)),
-            compile_path:     Normalizer.Task(Default.method(:compile_path)),
-            runtime_id:       Normalizer.Task(Default.method(:runtime_id)),
-            runtime_path:     Normalizer.Task(Default.method(:runtime_path)),
-            label:            Normalizer.Task(Default.method(:label)),
-            data:             Normalizer.Task(Default.method(:data)),
-          }.
-          collect { |id, task| Activity::TaskWrap::Pipeline.Row(id, task) }
-
-          PIPELINES = [Activity::TaskWrap::Pipeline.new(default_steps)] # we do mutate this constant at compile-time. Maybe # DISCUSS and find a better way.
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-module Trailblazer
-  module Developer
-    module Trace
-      module Debugger
-        class Node < Struct.new(:captured_node, :task, :activity, :compile_id, :compile_path, :runtime_id, :runtime_path, :label, :data, :captured_input, :captured_output, :level, keyword_init: true)
-          # The idea is to only work with {Activity} instances on this level, as that's the runtime concept.
-
-            # TODO: class, "type",
-            # which track, return signal, etc
-
-
-          # we always key options for specific nodes by Stack::Captured::Input, so we don't confuse activities if they were called multiple times.
-          def self.build(tree, enumerable_tree, node_options: {}, normalizer: Debugger::Normalizer::PIPELINES.last, **options_for_nodes)
-            parent_map = Trace::Tree::ParentMap.build(tree).to_h # DISCUSS: can we use {enumerable_tree} for {ParentMap}?
-
-
-            container_activity = enumerable_tree[0].captured_input.activity # TODO: any other way to grab the container_activity? Maybe via {activity.container_activity}?
-
-            top_activity = enumerable_tree[0].captured_input.task
-
-            # DISCUSS: this might change if we introduce a new Node type for Trace.
-            debugger_nodes = enumerable_tree[0..-1].collect do |node|
-              activity      = node.captured_input.activity
-              task          = node.captured_input.task
-              # it's possible to pass per-node options, like {label: "Yo!"} via {:node_options[<captured_input>]}
-              options       = node_options[node.captured_input] || {}
-
-
-              options_for_debugger_node, _ = normalizer.(
-                {
-                  captured_node:          node,
-                  task:                   task,
-                  activity:               activity,
-                  parent_map:             parent_map,
-                  **options
-                },
-                []
-              )
-
-              options_for_debugger_node = options_for_debugger_node.slice(*(options_for_debugger_node.keys - [:parent_map]))
-
-              # these attributes are not changing with the presentation
-              Debugger::Node.new(
-                captured_node:  node,
-                activity:       activity,
-                task:           task,
-
-                level: node.level,
-                captured_input: node.captured_input,
-                captured_output: node.captured_output,
-
-                **options_for_debugger_node,
-              ).freeze
-            end
-          end
-
-          def self.build_for_stack(stack, **options_for_debugger_nodes)
-            tree, processed = Trace.Tree(stack.to_a)
-
-            enumerable_tree = Trace::Tree.Enumerable(tree)
-
-            Debugger::Node.build(
-              tree,
-              enumerable_tree,
-              **options_for_debugger_nodes,
-            )
-          end
-        end
-      end # Debugger
-    end # Trace
-  end
-end