floatable-rails 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c125142ad80b216bb4877b12f84b9cbed92d61225c13486ea3468aca4247f72
-  data.tar.gz: 8693d60951dc3bb1631a1399f3bab47d9a2758d989cdf950542f738a9fe46053
+  metadata.gz: e24ac3ac7be11f6b3ef371aa01f178361fb4eac3a3826a324f3774ca56005ad0
+  data.tar.gz: 9b07e10f8906475a817797eecc6cb961fe90b9938a47f46cfeaf860d03acf005
 SHA512:
-  metadata.gz: f4a76a6b78be41abf4f1ac7cf5d889aea041486560bfe0ae394197c2c3761b439239c01ddf4a3350a8952586d41fcde1739c23dd5732a22b4a4e789cc6502c56
-  data.tar.gz: 7058a3f4efa223046b51057393ae68c5ed0f69fed2070fff360b7ed266cfd74fd4ebf57a1df2df3322bb9b7cb517f343209ebfdf1aa35f95c1565fa3571aaf60
+  metadata.gz: 97fb690d9c0081d42401fb42dc5189a281b123a925168563e72a6baf1d2e92d1dc05f3302c8b8e5f8d89b9a3eb7a7a1573916b8279a0271e122186eda60c38c3
+  data.tar.gz: 3cd295707a169159a79cb1b576249115c4b2fbd696c5abf473369f027984965e0702d1a6e8ab9118cd844ee3c040b69be20584d4f222c0a1c7b2fb09c29efdf1

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.6
+
+- Simplify instrumentation to path-only metadata (`data-floatable-path`).
+- Remove tag instrumentation and rely on view marker + middleware assignment.
+- Harden fail-open behavior so Floatable errors are logged and do not break host app requests.
+
 ## 0.1.5
 
 - Preserve Vue-style directive/event attributes by using the HTML5 parser when available.

data/README.md

@@ -1,7 +1,7 @@
 # Floatable::Rails
 
 Rails integration for Floatable Toolbar. It instruments HTML output with
-metadata and injects the Floatable script so your UI can be inspected and
+`data-floatable-path` attributes and injects the Floatable script so your UI can be inspected and
 annotated in the browser.
 
 ## Usage

data/lib/floatable/rails/engine.rb

@@ -1,6 +1,5 @@
 require "rails"
 require "floatable/rails/helpers"
-require "floatable/rails/tag_instrumentation"
 require "floatable/rails/erb_view_instrumentation"
 require "floatable/rails/slim_view_instrumentation"
 require "floatable/rails/response_middleware"
@@ -9,37 +8,82 @@ module Floatable
   module Rails
     class Engine < ::Rails::Engine
       isolate_namespace Floatable::Rails
+      class << self
+        def with_fail_open_init(name)
+          yield
+        rescue => e
+          ::Floatable::Rails.log_error("[Floatable::Rails::Engine] #{name} init failed: #{e.class} - #{e.message}")
+        end
+
+        def apply_erb_patch!
+          handler = ::ActionView::Template::Handlers::ERB
+          unless handler.ancestors.include?(::Floatable::Rails::ErbHandlerPatch)
+            handler.prepend(::Floatable::Rails::ErbHandlerPatch)
+          end
+
+          unless handler.erb_implementation == ::Floatable::Rails::ErubiWithFloatableViewMarkers
+            handler.erb_implementation = ::Floatable::Rails::ErubiWithFloatableViewMarkers
+          end
+        end
+
+        def apply_slim_patch!
+          return unless defined?(::Slim::RailsTemplate)
+
+          slim_handler = ::Slim::RailsTemplate
+          return if slim_handler.ancestors.include?(::Floatable::Rails::SlimHandlerPatch)
+
+          slim_handler.prepend(::Floatable::Rails::SlimHandlerPatch)
+        end
+      end
 
       initializer "floatable.rails.view_helpers" do
         ActiveSupport.on_load(:action_view) do
-          include ::Floatable::Rails::Helpers
-          prepend ::Floatable::Rails::TagInstrumentation
+          ::Floatable::Rails::Engine.with_fail_open_init("view_helpers") do
+            include ::Floatable::Rails::Helpers
+          end
         end
       end
 
       initializer "floatable.rails.erb_view_instrumentation" do
         ActiveSupport.on_load(:action_view) do
-          ::ActionView::Template::Handlers::ERB.prepend(::Floatable::Rails::ErbHandlerPatch)
-          ::ActionView::Template::Handlers::ERB.erb_implementation = ::Floatable::Rails::ErubiWithFloatableViewMarkers
+          ::Floatable::Rails::Engine.with_fail_open_init("erb_view_instrumentation") do
+            ::Floatable::Rails::Engine.apply_erb_patch!
+          end
+        end
+
+        config.after_initialize do
+          ::Floatable::Rails::Engine.with_fail_open_init("erb_view_instrumentation(after_initialize)") do
+            ::Floatable::Rails::Engine.apply_erb_patch!
+          end
         end
       end
 
       initializer "floatable.rails.slim_view_instrumentation" do
         ActiveSupport.on_load(:action_view) do
-          next unless defined?(::Slim::RailsTemplate)
+          ::Floatable::Rails::Engine.with_fail_open_init("slim_view_instrumentation") do
+            ::Floatable::Rails::Engine.apply_slim_patch!
+          end
+        end
 
-          ::Slim::RailsTemplate.prepend(::Floatable::Rails::SlimHandlerPatch)
+        config.after_initialize do
+          ::Floatable::Rails::Engine.with_fail_open_init("slim_view_instrumentation(after_initialize)") do
+            ::Floatable::Rails::Engine.apply_slim_patch!
+          end
         end
       end
 
       initializer "floatable.rails.controller_helpers" do
         ActiveSupport.on_load(:action_controller_base) do
-          helper ::Floatable::Rails::Helpers
+          ::Floatable::Rails::Engine.with_fail_open_init("controller_helpers") do
+            helper ::Floatable::Rails::Helpers
+          end
         end
       end
 
       initializer "floatable.rails.middleware" do |app|
-        app.middleware.use ::Floatable::Rails::ResponseMiddleware
+        ::Floatable::Rails::Engine.with_fail_open_init("middleware") do
+          app.middleware.use ::Floatable::Rails::ResponseMiddleware
+        end
       end
     end
   end

data/lib/floatable/rails/erb_view_instrumentation.rb

@@ -21,28 +21,37 @@ module Floatable
         }
 
         self.class.erb_implementation.new(erb, options).src
+      rescue => e
+        ::Floatable::Rails.log_error("[Floatable::Rails::ErbHandlerPatch] instrumentation failed: #{e.class} - #{e.message}")
+        super(template, source)
       end
     end
 
     class ErubiWithFloatableViewMarkers < ::ActionView::Template::Handlers::ERB::Erubi
       def initialize(input, properties = {})
-        view_path = floatable_views_path(properties[:filename])
-
-        if view_path.present?
-          properties = properties.dup
-          bufvar = properties[:bufvar] || "@output_buffer"
-          postamble = properties[:postamble] || bufvar
-
-          properties[:preamble] =
-            "#{properties[:preamble]}" \
-            "@output_buffer.safe_append='<!-- #{::Floatable::Rails::VIEW_COMMENT_BEGIN} #{view_path} -->' if Thread.current[:floatable_enabled];"
-
-          properties[:postamble] =
-            "@output_buffer.safe_append='<!-- #{::Floatable::Rails::VIEW_COMMENT_END} #{view_path} -->' if Thread.current[:floatable_enabled];" \
-            "#{postamble}"
+        instrumented_properties = properties
+
+        begin
+          view_path = floatable_views_path(properties[:filename])
+
+          if view_path.present?
+            instrumented_properties = properties.dup
+            bufvar = instrumented_properties[:bufvar] || "@output_buffer"
+            postamble = instrumented_properties[:postamble] || bufvar
+
+            instrumented_properties[:preamble] =
+              "#{instrumented_properties[:preamble]}" \
+              "@output_buffer.safe_append='<!-- #{::Floatable::Rails::VIEW_COMMENT_BEGIN} #{view_path} -->' if Thread.current[:floatable_enabled];"
+
+            instrumented_properties[:postamble] =
+              "@output_buffer.safe_append='<!-- #{::Floatable::Rails::VIEW_COMMENT_END} #{view_path} -->' if Thread.current[:floatable_enabled];" \
+              "#{postamble}"
+          end
+        rescue => e
+          ::Floatable::Rails.log_error("[Floatable::Rails::ErubiWithFloatableViewMarkers] initialize instrumentation failed: #{e.class} - #{e.message}")
         end
 
-        super
+        super(input, instrumented_properties)
       end
 
       private

data/lib/floatable/rails/helpers.rb

@@ -5,6 +5,9 @@ module Floatable
         return false unless respond_to?(:request)
 
         ::Floatable::Rails.enabled_for?(request)
+      rescue => e
+        ::Floatable::Rails.log_error("[Floatable::Rails::Helpers] floatable_enabled? failed: #{e.class} - #{e.message}")
+        false
       end
 
       def floatable_tag
@@ -19,6 +22,9 @@ module Floatable
           defer: false,
           data: ::Floatable::Rails.script_data_attributes
         )
+      rescue => e
+        ::Floatable::Rails.log_error("[Floatable::Rails::Helpers] floatable_tag failed: #{e.class} - #{e.message}")
+        nil
       end
     end
   end

data/lib/floatable/rails/response_middleware.rb

@@ -1,5 +1,4 @@
 require "nokogiri"
-require "base64"
 
 module Floatable
   module Rails
@@ -9,11 +8,13 @@ module Floatable
       end
 
       def call(env)
+        status = headers = body = nil
+        raw = nil
+
         enabled = floatable_enabled?(env)
         instrument = enabled && ::Floatable::Rails.instrumentation_enabled?
         Thread.current[:floatable_enabled] = instrument
 
-        status = headers = body = nil
         begin
           status, headers, body = @app.call(env)
         ensure
@@ -23,9 +24,7 @@ module Floatable
         return [ status, headers, body ] unless enabled
         return [ status, headers, body ] unless html_response?(status, headers)
 
-        raw = +""
-        body.each { |chunk| raw << chunk.to_s }
-        body.close if body.respond_to?(:close)
+        raw = read_body(body)
 
         instrumented = instrument ? instrument_html(raw) : raw
         final_html = inject_script(instrumented)
@@ -34,23 +33,29 @@ module Floatable
 
         [ status, headers, [ final_html ] ]
       rescue => e
-        ::Rails.logger.error("[Floatable::Rails::ResponseMiddleware] failed: #{e.class} - #{e.message}")
-        if e.backtrace
-          e.backtrace.first(30).each do |line|
-            ::Rails.logger.error("  #{line}")
-          end
-        end
-
-        raise if ::Rails.env.development? || ::Rails.env.test?
+        ::Floatable::Rails.log_error("[Floatable::Rails::ResponseMiddleware] failed: #{e.class} - #{e.message}")
+        ::Floatable::Rails.log_backtrace(e)
+        return [ status, headers, [ raw ] ] if raw
+        return [ status, headers, body ] if status && headers && body
 
-        status ||= 500
-        headers ||= {}
-        body ||= []
-        [ status, headers, body ]
+        raise
       end
 
       private
 
+      def read_body(body)
+        raw = +""
+        return raw if body.nil?
+
+        body.each { |chunk| raw << chunk.to_s }
+        raw
+      rescue => e
+        ::Floatable::Rails.log_error("[Floatable::Rails::ResponseMiddleware] read_body failed: #{e.class} - #{e.message}")
+        raw
+      ensure
+        body.close if body.respond_to?(:close)
+      end
+
       def html_response?(status, headers)
         return false unless status == 200
         ct = headers["Content-Type"] || headers["content-type"]
@@ -61,7 +66,7 @@ module Floatable
         req = ::Rack::Request.new(env)
         ::Floatable::Rails.enabled_for?(req)
       rescue => e
-        ::Rails.logger.error("[Floatable::Rails::ResponseMiddleware] enabled? failed: #{e.class} - #{e.message}")
+        ::Floatable::Rails.log_error("[Floatable::Rails::ResponseMiddleware] enabled? failed: #{e.class} - #{e.message}")
         false
       end
 
@@ -70,26 +75,19 @@ module Floatable
 
         doctype = html[/\A\s*<!DOCTYPE[^>]*>/i]
         doc = parse_html(html)
-
-        doc.css("*").each do |node|
-          name = node.name.to_s.downcase
-          next if %w[script style].include?(name)
-        end
-
-        apply_view_markers_and_assign_ids(doc)
+        apply_view_markers_and_assign_paths(doc)
 
         rendered = doc.to_html
         return rendered if doctype.nil? || rendered.lstrip.start_with?("<!DOCTYPE")
 
         "#{doctype}\n#{rendered}"
       rescue => e
-        ::Rails.logger.debug("[Floatable::Rails] HTML instrumentation failed: #{e.class} - #{e.message}")
+        ::Floatable::Rails.log_debug("[Floatable::Rails] HTML instrumentation failed: #{e.class} - #{e.message}")
         html
       end
 
-      def apply_view_markers_and_assign_ids(doc)
+      def apply_view_markers_and_assign_paths(doc)
         view_stack = []
-        counters = Hash.new(0)
 
         doc.traverse do |node|
           if node.comment?
@@ -119,17 +117,12 @@ module Floatable
           next if current_path.blank?
 
           node["data-floatable-path"] ||= current_path
-          if node["data-floatable-id"].blank?
-            counters[current_path] += 1
-            encoded = Base64.urlsafe_encode64(counters[current_path].to_s, padding: false)
-            node["data-floatable-id"] = "#{current_path}:#{encoded}"
-          end
         end
 
         # Remove all comments, including our markers.
         doc.xpath("//comment()").remove
       rescue => e
-        ::Rails.logger.debug("[Floatable::Rails] apply_view_markers_and_assign_ids failed: #{e.class} - #{e.message}")
+        ::Floatable::Rails.log_debug("[Floatable::Rails] apply_view_markers_and_assign_paths failed: #{e.class} - #{e.message}")
       end
 
       def parse_html(html)
@@ -162,7 +155,7 @@ module Floatable
           html + snippet
         end
       rescue => e
-        ::Rails.logger.error("[Floatable::Rails::ResponseMiddleware] inject_script failed: #{e.class} - #{e.message}")
+        ::Floatable::Rails.log_error("[Floatable::Rails::ResponseMiddleware] inject_script failed: #{e.class} - #{e.message}")
         html
       end
     end

data/lib/floatable/rails/slim_view_instrumentation.rb

@@ -54,7 +54,14 @@ module Floatable
         view_path = floatable_views_path(template.identifier)
         return super if view_path.nil?
 
-        instrumented = SlimViewMarkerInstrumenter.instrument(source || template.source, view_path)
+        instrumented =
+          begin
+            SlimViewMarkerInstrumenter.instrument(source || template.source, view_path)
+          rescue => e
+            ::Floatable::Rails.log_error("[Floatable::Rails::SlimHandlerPatch] instrumentation failed: #{e.class} - #{e.message}")
+            return super
+          end
+
         super(template, instrumented)
       end
 

data/lib/floatable/rails/version.rb

@@ -1,5 +1,5 @@
 module Floatable
   module Rails
-    VERSION = "0.1.5"
+    VERSION = "0.1.6"
   end
 end

data/lib/floatable/rails.rb

@@ -46,6 +46,28 @@ module Floatable
     end
 
     class << self
+      def log_error(message)
+        ::Rails.logger&.error(message)
+      rescue
+        nil
+      end
+
+      def log_debug(message)
+        ::Rails.logger&.debug(message)
+      rescue
+        nil
+      end
+
+      def log_backtrace(error, limit: 30)
+        return unless error&.backtrace
+
+        error.backtrace.first(limit).each do |line|
+          log_error("  #{line}")
+        end
+      rescue
+        nil
+      end
+
       def config
         @config ||= Configuration.new
       end
@@ -61,16 +83,22 @@ module Floatable
 
         !!predicate.call(request)
       rescue => e
-        ::Rails.logger.error("[Floatable::Rails] enabled_for? failed: #{e.class} - #{e.message}")
+        log_error("[Floatable::Rails] enabled_for? failed: #{e.class} - #{e.message}")
         false
       end
 
       def instrumentation_enabled?
         config.instrumentation_enabled != false
+      rescue => e
+        log_error("[Floatable::Rails] instrumentation_enabled? failed: #{e.class} - #{e.message}")
+        false
       end
 
       def script_src
         config.script_src
+      rescue => e
+        log_error("[Floatable::Rails] script_src failed: #{e.class} - #{e.message}")
+        nil
       end
 
       def script_data
@@ -81,10 +109,16 @@ module Floatable
           branch: config.script_branch,
           agent_tools_mode: config.script_agent_tools_mode
         }.reject { |_key, value| value.nil? || (value.respond_to?(:empty?) && value.empty?) }
+      rescue => e
+        log_error("[Floatable::Rails] script_data failed: #{e.class} - #{e.message}")
+        {}
       end
 
       def script_data_attributes
         script_data.transform_keys { |key| :"floatable_#{key}" }
+      rescue => e
+        log_error("[Floatable::Rails] script_data_attributes failed: #{e.class} - #{e.message}")
+        {}
       end
 
       def script_data_attributes_html
@@ -94,6 +128,9 @@ module Floatable
         data.map do |key, value|
           %( data-floatable-#{key.to_s.tr("_", "-")}="#{ERB::Util.html_escape(value.to_s)}")
         end.join
+      rescue => e
+        log_error("[Floatable::Rails] script_data_attributes_html failed: #{e.class} - #{e.message}")
+        ""
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: floatable-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Tobias Almstrand
@@ -41,7 +41,6 @@ files:
 - lib/floatable/rails/helpers.rb
 - lib/floatable/rails/response_middleware.rb
 - lib/floatable/rails/slim_view_instrumentation.rb
-- lib/floatable/rails/tag_instrumentation.rb
 - lib/floatable/rails/version.rb
 homepage: https://floatable.dev
 licenses:

data/lib/floatable/rails/tag_instrumentation.rb

@@ -1,181 +0,0 @@
-require "pathname"
-require "base64"
-
-module Floatable
-  module Rails
-    module TagInstrumentation
-      def content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)
-        if floatable_enabled_for_view?
-          options = ensure_options_hash(content_or_options_with_block, options)
-          file, line = floatable_callsite
-
-          if file
-            options[:"data-floatable-path"] ||= floatable_relative_path(file)
-            if line
-              encoded = Base64.urlsafe_encode64(line.to_s, padding: false)
-              options[:"data-floatable-id"] ||= "#{options[:"data-floatable-path"]}:#{encoded}"
-            end
-          end
-
-          # Re-shape args for super if we mutated them
-          if content_or_options_with_block.is_a?(Hash) && options
-            content_or_options_with_block = options
-            options = nil
-          end
-        end
-
-        super
-      end
-
-      def tag(name = nil, options = nil, open = false, escape = true)
-        if floatable_enabled_for_view? && name
-          options = (options || {}).dup
-          file, line = floatable_callsite
-
-          if file
-            options[:"data-floatable-path"] ||= floatable_relative_path(file)
-            if line
-              encoded = Base64.urlsafe_encode64(line.to_s, padding: false)
-              options[:"data-floatable-id"] ||= "#{options[:"data-floatable-path"]}:#{encoded}"
-            end
-          end
-
-          return super(name, options, open, escape)
-        end
-
-        super
-      end
-
-      private
-
-      def floatable_enabled_for_view?
-        return false unless respond_to?(:request)
-
-        ::Floatable::Rails.instrumentation_enabled? && ::Floatable::Rails.enabled_for?(request)
-      rescue => e
-        ::Rails.logger.error("[Floatable::Rails::TagInstrumentation] enabled? failed: #{e.class} - #{e.message}")
-        false
-      end
-
-      def ensure_options_hash(content_or_options_with_block, options)
-        if content_or_options_with_block.is_a?(Hash) && options.nil?
-          content_or_options_with_block
-        else
-          options || {}
-        end
-      end
-
-      # Callsite detection
-      #
-      # We want the *template* or app file (e.g. app/views/posts/index.html.erb),
-      # not ActionView's gem helpers.
-      #
-      # Strategy:
-      #   - Walk the call stack.
-      #   - Pick the first frame whose path starts with Rails.root
-      #     (so we ignore anything under ~/.rbenv, /gems/, etc).
-      #   - Prefer files under app/views, but accept any app file as fallback.
-      #
-      def floatable_callsite
-        app_root = ::Rails.root.to_s
-        return [ nil, nil ] if app_root.blank?
-
-        locations = caller_locations(2, 200) || []
-
-        template_path = floatable_current_template_path
-        if template_path
-          loc = locations.find { |loc_item| loc_item.path.to_s == template_path }
-          return [ template_path, loc.lineno ] if loc
-        end
-
-        # First pass: prefer app/views templates, excluding layouts when possible.
-        view_locs = locations.select do |loc|
-          path = loc.path.to_s
-          path.start_with?(app_root) && path.include?("/app/views/") && path.end_with?(".erb")
-        end
-
-        unless view_locs.empty?
-          non_layout = view_locs.reverse.find { |loc| !loc.path.to_s.include?("/app/views/layouts/") }
-          chosen = non_layout || view_locs.last
-          return [ chosen.path, chosen.lineno ]
-        end
-
-        # Second pass: any file under Rails.root (app/models, app/controllers, etc)
-        app_loc = locations.find do |loc|
-          path = loc.path.to_s
-          path.start_with?(app_root)
-        end
-
-        if app_loc
-          return [ app_loc.path, app_loc.lineno ]
-        end
-
-        # If nothing inside the app, we give up and return nil
-        [ nil, nil ]
-      rescue => e
-        ::Rails.logger.debug("[Floatable::Rails::TagInstrumentation] floatable_callsite failed: #{e.class} - #{e.message}")
-        [ nil, nil ]
-      end
-
-      def floatable_current_template_path
-        return nil unless respond_to?(:lookup_context)
-
-        current_template = floatable_current_template_identifier
-        return current_template if current_template.present?
-
-        vpath = floatable_virtual_path
-        return nil if vpath.empty?
-
-        templates = lookup_context.find_all(vpath, [], true)
-        template = templates.first || lookup_context.find_all(vpath, [], false).first
-        identifier = template&.identifier.to_s
-        identifier.presence
-      rescue
-        nil
-      end
-
-      def floatable_current_template_identifier
-        return nil unless instance_variable_defined?(:@current_template)
-
-        template = instance_variable_get(:@current_template)
-        identifier = template&.identifier.to_s
-        identifier.presence
-      rescue
-        nil
-      end
-
-      def floatable_virtual_path
-        vpath = nil
-        vpath = virtual_path.to_s if respond_to?(:virtual_path)
-
-        if vpath.to_s.empty?
-          vpath = instance_variable_get(:@virtual_path).to_s if instance_variable_defined?(:@virtual_path)
-        end
-
-        if vpath.to_s.empty?
-          vpath = instance_variable_get(:@_virtual_path).to_s if instance_variable_defined?(:@_virtual_path)
-        end
-
-        vpath.to_s
-      rescue
-        ""
-      end
-
-      def floatable_relative_path(file)
-        return nil if file.blank?
-
-        app_root = ::Rails.root.to_s
-        return file unless app_root.present?
-
-        # Only record paths inside the app root; ignore gems/rbenv/etc.
-        unless file.start_with?(app_root)
-          return nil
-        end
-
-        Pathname.new(file).relative_path_from(Pathname.new(app_root)).to_s
-      rescue
-        file
-      end
-    end
-  end
-end