Trace now works via canonical invoke.

Author: apotonick

lib/trailblazer/developer/trace.rb

@@ -1,37 +1,39 @@
 module Trailblazer::Developer
   module Trace
     class << self
-      # 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!
-
-        signal, (ctx, flow_options) = Trailblazer::Activity::TaskWrap.invoke(activity, [ctx, flow_options], **circuit_options)
-
-        return flow_options[:stack], signal, [ctx, flow_options]
-      end
-
-      alias_method :invoke, :call
-
-      def arguments_for_call(activity, (options, original_flow_options), **original_circuit_options)
-        default_flow_options = {
+      # Follows the interface for options-compiler.
+      # @private
+      def invoke_options_compiler_step(activity, options, **)
+        flow_options = {
           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)}
-
-        # TODO: we should, at this point, merge all runtime Ext() objects instead of overriding.
-        default_circuit_options = {
+        circuit_options = {
           wrap_runtime:  ::Hash.new(Trace.task_wrap_extensions), # FIXME: this overrides existing {:wrap_runtime}.
         }
 
-        circuit_options = {**original_circuit_options, **default_circuit_options}
+        # those will be deep_merged in invoke's options-compiler?
+        {
+          flow_options:     flow_options,
+          circuit_options:  circuit_options
+        }
+      end
+
+      # 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.
 
-        return activity, [options, flow_options], circuit_options
+      # DISCUSS: could this be a constant?
+      # @public
+      def options_for_canonical_invoke(adds_for_options_compiler: [], **options) # TODO: can be a constant.
+        {
+          adds_for_options_compiler: [
+            [Trailblazer::Invoke::Options::HeuristicMerge.build(method(:invoke_options_compiler_step)), id: "developer.trace", append: nil],
+          ] + adds_for_options_compiler
+        }
       end
     end
 

test/test_helper.rb

@@ -1,12 +1,12 @@
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "trailblazer/developer"
+require "trailblazer/core"
 
 require "minitest/autorun"
 require "pp"
 
-require "trailblazer/activity"
-require "trailblazer/activity/testing"
 require "trailblazer/activity/dsl/linear"
+require "trailblazer/activity/testing"
 puts "Running in Ruby #{RUBY_VERSION}"
 
 T = Trailblazer::Activity::Testing
@@ -16,6 +16,8 @@ def assert_equal(asserted, expected, *args)
     super(expected, asserted, *args)
   end
 
+  CU = Trailblazer::Core::Utils
+
   Dev = Trailblazer::Developer
   include Trailblazer::Activity::Testing::Assertions
 

test/trace_test.rb

@@ -1,49 +1,40 @@
 require "test_helper"
 
-# Test {Trace.call} and {Trace::Present.call}
-class TraceTest < Minitest::Spec
-  it "traces flat strategy" do
-    stack, signal, (ctx, flow_options), _ = Dev::Trace.invoke(flat_activity, [{seq: []}, {flow: true}])
-
-    assert_equal signal.class.inspect, %{Trailblazer::Activity::End}
-
-    assert_equal ctx.inspect, %{{:seq=>[:B, :C]}}
-    assert_equal flow_options[:flow].inspect, %{true}
-
-    output = Dev::Trace::Present.(stack)
-    output = output.gsub(/0x\w+/, "").gsub(/0x\w+/, "").gsub(/@.+_test/, "")
-
-    assert_equal output, %{#<Class:>
-|-- Start.default
-|-- B
-|-- C
-`-- End.success}
+require "trailblazer/invoke"
+class TraceInvokeTest < Minitest::Spec
+  let(:kernel) do
+    Class.new do
+      Trailblazer::Invoke.module!(self)
+    end.new
   end
 
-  it "traces flat activity" do
-    activity = flat_activity.to_h[:activity]
-
-    stack, signal, (ctx, flow_options), _ = Dev::Trace.invoke(activity, [{seq: []}, {flow: true}])
-
-    assert_equal signal.class.inspect, %{Trailblazer::Activity::End}
+  it "traces a flat activity" do
+    signal, (ctx, flow_options), _ = kernel.__(
+      flat_activity,
+      {seq: []},
+      **Trailblazer::Developer::Trace.options_for_canonical_invoke
+    )
 
-    assert_equal ctx.inspect, %{{:seq=>[:B, :C]}}
-    assert_equal flow_options[:flow].inspect, %{true}
+    assert_equal signal.to_h[:semantic], :success
+    assert_equal CU.inspect(ctx.to_h), %({:seq=>[:B, :C]})
 
-    output = Dev::Trace::Present.(stack)
+    stack = flow_options[:stack]
+    output = Trailblazer::Developer::Trace::Present.(stack)
     output = output.gsub(/0x\w+/, "").gsub(/0x\w+/, "").gsub(/@.+_test/, "")
 
-    assert_equal output, %{#<Trailblazer::Activity:>
+    assert_equal output, %(#<Class:>
 |-- Start.default
 |-- B
 |-- C
-`-- End.success}
+`-- End.success)
   end
 
-  it "you can pass an explicit task label via {:label}" do
-    stack, signal, (ctx, flow_options), _ = Dev::Trace.invoke(flat_activity, [{seq: []}, {}])
+  # TODO: can we add more {:wrap_runtime}?
 
-    output = Dev::Trace::Present.(stack) do |trace_nodes:, **|
+  it "{Present}: you can pass an explicit task label via {:label}" do
+    signal, (ctx, flow_options), _ = kernel.__(flat_activity, {seq: []}, **Trailblazer::Developer::Trace.options_for_canonical_invoke)
+
+    output = Dev::Trace::Present.(flow_options[:stack]) do |trace_nodes:, **|
       {
         node_options: {
           trace_nodes[0] => {label: "#{flat_activity.class} (anonymous)"}
@@ -61,13 +52,9 @@ class TraceTest < Minitest::Spec
   it "nested tracing" do
     activity, sub_activity, _activity = Tracing.three_level_nested_activity(e_options: {Trailblazer::Activity::Railway.Out() => [:nil_value]})
 
-    stack, signal, (ctx, flow_options) = Dev::Trace.invoke(
-      activity,
-      [
-        {seq: []},
-        {flow: true}
-      ]
-    )
+    signal, (ctx, flow_options) = kernel.__(activity, {seq: []}, **Trailblazer::Developer::Trace.options_for_canonical_invoke)
+
+    stack = flow_options[:stack]
 
     assert_equal ctx[:seq], [:a, :b, :c, :d, :e]
 
@@ -109,8 +96,45 @@ class TraceTest < Minitest::Spec
 |-- e
 `-- End.success}
   end
+end
+
+# Test {Trace.call} and {Trace::Present.call}
+class TraceTest < Minitest::Spec
+  # This is for people who were using Developer::Trace.(MyActivity) to trace on their own.
+  it "allows tracing by manually passing the options" do
+    trace_args = Trailblazer::Developer::Trace.invoke_options_compiler_step(flat_activity, {})
+
+    signal, (ctx, flow_options), _ = Trailblazer::Activity::TaskWrap.invoke(
+      flat_activity,
+      [
+        {seq: []},
+        trace_args[:flow_options]
+      ],
+      **trace_args[:circuit_options]
+    )
+
+    assert_equal signal.to_h[:semantic], :success
+    assert_equal CU.inspect(ctx.to_h), %({:seq=>[:B, :C]})
+
+    stack = flow_options[:stack]
+    output = Trailblazer::Developer::Trace::Present.(stack)
+    output = output.gsub(/0x\w+/, "").gsub(/0x\w+/, "").gsub(/@.+_test/, "")
+
+    assert_equal output, %(#<Class:>
+|-- Start.default
+|-- B
+|-- C
+`-- End.success)
+  end
+end
 
-    # Test custom classes without explicit {#hash} implementation.
+# Test specific options such as {:snapshooter}.
+class TraceAPITest < Minitest::Spec
+  let(:kernel) do
+    Class.new { Trailblazer::Invoke.module!(self) }.new
+  end
+
+  # Test custom classes without explicit {#hash} implementation.
   class User
     def initialize(id)
       @id = id
@@ -163,17 +187,14 @@ def authorize(ctx, current_user:, seq:, **)
       after_snapshooter:  Snapshot.method(:after_snapshooter),
     }
 
-    activity = ::TraceTest::Endpoint
-
-    stack, signal, (ctx, flow_options) = Dev::Trace.invoke(
-      activity,
-      [
-        {
-          current_user: current_user = User.new(1),
-          params: {name: "Q & I"},
-          seq: [],
-        },
-      ]
+    signal, (ctx, flow_options) = kernel.__(
+      Endpoint,
+      {
+        current_user: current_user = User.new(1),
+        params: {name: "Q & I"},
+        seq: [],
+      },
+      **Trailblazer::Developer::Trace.options_for_canonical_invoke
     )
 
 
@@ -197,7 +218,7 @@ def authorize(ctx, current_user:, seq:, **)
 
 
     # This is a unit test we might not need anymore:
-    assert_equal stack[0].task, ::TraceTest::Endpoint
+    assert_equal stack[0].task, Endpoint
     assert_snapshot versions, stack[0], current_user: 0, params: 0, seq: 0
 
     assert_equal stack[1].task.inspect, %(#<Trailblazer::Activity::Start semantic=:default>)
@@ -218,7 +239,7 @@ def authorize(ctx, current_user:, seq:, **)
     assert_snapshot versions, stack[6], current_user: 0, params: 0, seq: 2
 
     # Create {in}
-    assert_equal stack[7].task, ::TraceTest::Endpoint::Create
+    assert_equal stack[7].task, Endpoint::Create
     assert_snapshot versions, stack[7], current_user: 0, params: 0, seq: 2
 
       # Create :model
@@ -238,7 +259,7 @@ def authorize(ctx, current_user:, seq:, **)
       assert_snapshot versions, stack[15], current_user: 0, params: 1, seq: 4, model: 0
 
     # Create {out}
-    assert_equal stack[16].task, ::TraceTest::Endpoint::Create
+    assert_equal stack[16].task, Endpoint::Create
     assert_snapshot versions, stack[16], current_user: 0, params: 1, seq: 4, model: 0
 
     # Endpoint End.success
@@ -273,8 +294,9 @@ def create(ctx, **)
       end
     end
 
-    stack, signal, (ctx, flow_options) = Dev::Trace.invoke(activity, [{}, {}])
+    signal, (ctx, flow_options) = kernel.__(activity, {}, **Trailblazer::Developer::Trace.options_for_canonical_invoke)
 
+    stack = flow_options[:stack]
     nodes = stack.to_a
 
     # :override/after
@@ -305,12 +327,26 @@ def create(ctx, **)
       end
     end
 
-    stack, signal, (ctx, flow_options) = Dev::Trace.invoke(activity, [{params: {}},
-      {
-        value_snapshooter: value_snapshooter
-      }
-    ])
+    trace_args_for_invoke = Trailblazer::Developer::Trace.options_for_canonical_invoke(
+      adds_for_options_compiler: [
+        [
+          Trailblazer::Invoke::Options::HeuristicMerge.build(
+            ->(*) do
+              {
+                flow_options: {
+                  value_snapshooter: value_snapshooter
+                }
+              }
+            end
+          ),
+          id: "user.trace.value_snapshooter_options", append: nil
+        ]
+      ]
+    )
 
+    signal, (ctx, flow_options) = kernel.__(activity, {params: {}}, **trace_args_for_invoke)
+
+    stack = flow_options[:stack]
     nodes = stack.to_a
 
     # Op/after
@@ -326,8 +362,9 @@ def create(ctx, **)
   # We can also set it via {Trace.value_snapshooter}
     Trailblazer::Developer::Trace.instance_variable_set(:@value_snapshooter, value_snapshooter)
 
-    stack, signal, (ctx, flow_options) = Dev::Trace.invoke(activity, [{params: {}}, {}])
+    signal, (ctx, flow_options) = kernel.__(activity, {params: {}}, **Trailblazer::Developer::Trace.options_for_canonical_invoke)
 
+    stack = flow_options[:stack]
     nodes = stack.to_a
 
     # Op/after
@@ -342,25 +379,41 @@ def create(ctx, **)
     Trailblazer::Developer::Trace.instance_variable_set(:@value_snapshooter, Trailblazer::Developer::Trace::Snapshot::Value.build) # reset to original value.
   end
 
-  it "allows to inject custom :data_collector" do
-    input_collector = ->(wrap_config, ((ctx, _), _)) { [{ ctx: ctx, something: :else }, {}] }
-    output_collector = ->(wrap_config, ((ctx, _), _)) { [{ ctx: ctx, signal: wrap_config[:return_signal] }, {}] }
+  it "allows to inject custom data collector" do
+    input_collector = ->(wrap_ctx, ((ctx, _), _)) { [{ ctx: ctx.to_h, something: :else }, {}] }
+    output_collector = ->(wrap_ctx, ((ctx, _), _)) { [{ ctx: ctx.to_h, signal: wrap_ctx[:return_signal] }, {}] }
+
+    trace_args_for_invoke = Trailblazer::Developer::Trace.options_for_canonical_invoke(
+      adds_for_options_compiler: [
+        [
+          Trailblazer::Invoke::Options::HeuristicMerge.build(
+            ->(*) do
+              {
+                flow_options: {
+                  before_snapshooter: input_collector,
+                  after_snapshooter: output_collector,
+                }
+              }
+            end
+          ),
+          id: "user.trace.snapshooter_options", append: nil
+        ]
+      ]
+    )
 
-    stack, signal, (ctx, _) = Dev::Trace.invoke(
+    signal, (ctx, flow_options) = kernel.__(
       flat_activity,
-      [
         { seq: [] },
-        {
-          before_snapshooter: input_collector,
-          after_snapshooter: output_collector,
-        }
-      ]
+        **trace_args_for_invoke
     )
 
     assert_equal ctx[:seq], [:B, :C]
 
-    captured_input  = stack.to_a[0]
-    captured_output = stack.to_a[-1]
+    stack = flow_options[:stack].to_a
+    captured_input  = stack[0]
+    captured_output = stack[-1]
+
+    # pp stack
 
     assert_equal captured_input.data, { ctx: { seq: [:B, :C] }, something: :else }
     assert_equal captured_output.data, { ctx: { seq: [:B, :C] }, signal: signal }

trailblazer-developer.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest-line"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "trailblazer-operation", ">= 0.10.0"
+  spec.add_development_dependency "trailblazer-core-utils"
 
   spec.add_dependency "trailblazer-activity-dsl-linear", ">= 1.2.0", "< 1.3.0"
   spec.add_dependency "hirb"