Fix hermetic recorder host integration edge cases

Keep recorder hooks inert for host contexts without Liquid registers, capture only bytes produced by the template, and exclude memory-limited renders from the corpus. Strict replay now stubs application-only inline and block tags from the recorded sources.

Assisted-By: devx/948e6cb4-458b-480b-8d99-d726473b381b

Author: martelogan

lib/liquid/drop.rb

@@ -43,7 +43,12 @@ def invoke_drop(method_or_key)
         liquid_method_missing(method_or_key)
       end
 
-      recorder = @context&.registers&.[](TemplateRecorder::REGISTER_KEY) if defined?(TemplateRecorder)
+      # A host application may assign its own object as a drop's context, and a
+      # drop can be invoked outside any render. Neither case has registers, and
+      # instrumentation must never turn either into a NoMethodError.
+      if defined?(TemplateRecorder) && @context.respond_to?(:registers)
+        recorder = @context.registers[TemplateRecorder::REGISTER_KEY]
+      end
       recorder&.emit_drop_read(self, method_or_key, result)
       result
     end

lib/liquid/strainer_template.rb

@@ -56,7 +56,11 @@ def invoke(method, *args)
         args.first
       end
 
-      recorder = @context&.registers&.[](TemplateRecorder::REGISTER_KEY) if defined?(TemplateRecorder)
+      # See Drop#invoke_drop: the context is not guaranteed to be a
+      # Liquid::Context, and instrumentation must not raise.
+      if defined?(TemplateRecorder) && @context.respond_to?(:registers)
+        recorder = @context.registers[TemplateRecorder::REGISTER_KEY]
+      end
       recorder&.emit_filter_call(method, args.first, args.drop(1), result)
       result
     rescue ::ArgumentError => e

lib/liquid/template.rb

@@ -204,14 +204,23 @@ def render(*args)
 
       rendered_output = nil
       render_succeeded = false
+      # A caller may hand in a buffer that already holds bytes this template did
+      # not produce, and may keep appending to it after this render returns. The
+      # recording must describe only what the template rendered, so remember
+      # where its output starts.
+      recorded_output_start = recording ? (output || '').bytesize : 0
       begin
         # render the nodelist.
         rendered_output = @root.render_to_output_buffer(context, output || +'')
         render_succeeded = true
         rendered_output
       rescue Liquid::MemoryError => e
         rendered_output = context.handle_error(e)
-        render_succeeded = true
+        # The caller still gets the error text, but a render that hit the memory
+        # limit is truncated by definition: recording it as a success would put
+        # a partial render into the corpus as if it were the specified output.
+        render_succeeded = false
+        recorded_output_start = 0
         rendered_output
       ensure
         if previous_error_mode
@@ -225,7 +234,15 @@ def render(*args)
           else
             recorder_registers.delete(TemplateRecorder::REGISTER_KEY)
           end
-          recording_session.finish_render(recording, rendered_output, context, success: render_succeeded)
+          # Slice off any caller-supplied prefix, and copy: the buffer is the
+          # caller's and may still be appended to, which would otherwise leak
+          # bytes into a recording that has already been taken.
+          recorded_output = if rendered_output.is_a?(String)
+            rendered_output.byteslice(recorded_output_start, rendered_output.bytesize - recorded_output_start).dup
+          else
+            rendered_output
+          end
+          recording_session.finish_render(recording, recorded_output, context, success: render_succeeded)
         end
         @errors = context.errors
       end

lib/liquid/template_recorder.rb

@@ -17,6 +17,9 @@ class TemplateRecorder
     REGISTER_KEY = :__liquid_template_recorder
     REPLAYER_REGISTER_KEY = :__liquid_template_recorder_replayer
 
+    # Opening tag markup, with or without whitespace control.
+    TAG_NAME_PATTERN = /\{%-?\s*(\w+)/
+
     class Error < StandardError; end
     class ReplayError < Error; end
     class SerializationError < Error; end
@@ -509,11 +512,58 @@ def strict_environment
         tags&.each do |name, tag_class|
           tags[name] = replay_tag_class(tag_class, name)
         end
+        register_host_tag_stubs(tags)
         Liquid::Environment.build(tags: tags) do |environment|
           environment.strainer_template = strainer
         end
       end
 
+      # Registers a stub for every tag the recorded sources mention that this
+      # environment does not know.
+      #
+      # A recording taken inside a host application names that application's
+      # tags, and strict replay re-parses the recorded source. Without a stub
+      # the parse fails and the recording is replayable only inside the
+      # application it came from, which defeats the point of recording it.
+      #
+      # A stub is only ever parsed. A tag that was invoked has its recorded
+      # output substituted by +replay_tag_class+; a block stub consumes its
+      # body without rendering it, so a custom tag nested inside another one
+      # never executes and never consumes a recorded call.
+      def register_host_tag_stubs(tags)
+        names, blocks = host_tag_names(tags)
+
+        names.each do |name|
+          stub = blocks.include?(name) ? Liquid::Block : Liquid::Tag
+          tags[name] = replay_tag_class(Class.new(stub), name)
+        end
+      end
+
+      # Unknown tag names in every recorded source, and which of them are
+      # closed by a matching +end+ tag and so must parse as blocks.
+      def host_tag_names(known)
+        names = []
+        blocks = []
+
+        recorded_sources.each do |source|
+          source.scan(TAG_NAME_PATTERN) do |(name)|
+            if name.start_with?("end")
+              blocks << name.delete_prefix("end")
+            elsif !known.key?(name) && !names.include?(name)
+              names << name
+            end
+          end
+        end
+
+        [names, blocks]
+      end
+
+      def recorded_sources
+        sources = Array(@record["templates"]).filter_map { |template| template["source"] }
+        sources.concat(Array(@record["file_system"]&.values))
+        sources.compact
+      end
+
       def replay_tag_class(tag_class, name)
         replayer = self
         Class.new(tag_class) do

test/integration/template_recorder_test.rb

@@ -160,6 +160,17 @@ def test_render_failure_is_not_written_to_jsonl
     refute_path_exists(recording)
   end
 
+  def test_memory_limited_render_is_not_recorded_as_successful
+    writer = CollectingWriter.new
+    template = Liquid::Template.parse("0123456789")
+    template.resource_limits.render_length_limit = 9
+
+    output = Liquid::TemplateRecorder.record(writer) { template.render }
+
+    assert_equal("Liquid error: Memory limits exceeded", output)
+    assert_empty(writer.records)
+  end
+
   def test_tampered_template_is_rejected
     Liquid::TemplateRecorder.record(path) { Liquid::Template.parse("safe").render! }
     session = JSON.parse(File.read(path))
@@ -311,6 +322,35 @@ def test_unsupported_accessed_values_do_not_affect_the_render
     assert_equal({}, writer.records.first["assigns"])
   end
 
+  def test_recorder_hooks_accept_host_application_contexts
+    product = ProductDrop.new("Computed", "secret")
+    product.context = Object.new
+    assert_equal("Computed", product.invoke_drop("title"))
+
+    filter = Module.new do
+      def passthrough(input)
+        input
+      end
+    end
+    strainer_class = Class.new(Liquid::StrainerTemplate)
+    strainer_class.add_filter(filter)
+
+    assert_equal("value", strainer_class.new(Object.new).invoke(:passthrough, "value"))
+  end
+
+  def test_records_only_output_produced_by_the_template
+    writer = CollectingWriter.new
+    output = +"prefix:"
+
+    Liquid::TemplateRecorder.record(writer) do
+      Liquid::Template.parse("body").render!({}, output: output)
+      output << ":suffix"
+    end
+
+    assert_equal("prefix:body:suffix", output)
+    assert_equal("body", writer.records.first["output"])
+  end
+
   def test_strict_replay_accepts_the_application_environment
     environment = Liquid::Environment.build(
       tags: Liquid::Environment.default.tags.merge("marker" => MarkerTag),
@@ -329,6 +369,20 @@ def test_strict_replay_accepts_the_application_environment
     assert_equal("custom", replay.render)
   end
 
+  def test_strict_replay_stubs_host_application_tags
+    environment = Liquid::Environment.build(
+      tags: Liquid::Environment.default.tags.merge("wrapper" => WrapperTag, "marker" => MarkerTag),
+    )
+    writer = CollectingWriter.new
+    Liquid::TemplateRecorder.record(writer) do
+      Liquid::Template.parse("{% wrapper %}{% marker %}{% endwrapper %}", environment: environment).render!
+    end
+
+    replay = Liquid::TemplateRecorder::Replayer.new(writer.records.first, mode: :strict)
+
+    assert_equal("custom", replay.render)
+  end
+
   def test_captures_file_reads_that_happen_before_the_template_starts_rendering
     writer = CollectingWriter.new
     Liquid::TemplateRecorder.record(writer) do