skylight 4.2.1 → 5.0.0.beta

data/lib/skylight/normalizers/render.rb

@@ -0,0 +1,81 @@
+module Skylight
+  module Normalizers
+    # Base Normalizer for Rails rendering
+    class RenderNormalizer < Normalizer
+      include Skylight::Util::AllocationFree
+
+      def setup
+        @paths = []
+
+        Gem.path.each do |path|
+          @paths << "#{path}/bundler/gems".freeze
+          @paths << "#{path}/gems".freeze
+          @paths << path
+        end
+
+        @paths.concat(Array(config["normalizers.render.view_paths"]))
+      end
+
+      # Generic normalizer for renders
+      # @param category [String]
+      # @param payload [Hash]
+      # @option payload [String] :identifier
+      # @return [Array]
+      def normalize_render(category, payload)
+        if (path = payload[:identifier])
+          title = relative_path(path)
+        end
+
+        [category, title, nil]
+      end
+
+      def relative_path(path)
+        return path if relative_path?(path)
+
+        if (root = array_find(@paths) { |p| path.start_with?(p) })
+          start = root.size
+          start += 1 if path.getbyte(start) == SEPARATOR_BYTE
+
+          path[start, path.size].sub(
+            # Matches a Gem Version or 12-digit hex (sha)
+            # that is preceeded by a `-` and followed by `/`
+            # Also matches 'app/views/' if it exists
+            %r{-(?:#{Gem::Version::VERSION_PATTERN}|[0-9a-f]{12})\/(?:app\/views\/)*},
+            ": ".freeze
+          )
+        else
+          "Absolute Path".freeze
+        end
+      end
+
+      private
+
+        def relative_path?(path)
+          !absolute_path?(path)
+        end
+
+        SEPARATOR_BYTE = File::SEPARATOR.ord
+
+        if File.const_defined?(:NULL) ? File::NULL == "NUL" : RbConfig::CONFIG["host_os"] =~ /mingw|mswin32/
+          # This is a DOSish environment
+          ALT_SEPARATOR_BYTE = File::ALT_SEPARATOR&.ord
+          COLON_BYTE = ":".ord
+          SEPARATOR_BYTES = [SEPARATOR_BYTE, ALT_SEPARATOR_BYTE].freeze
+
+          def absolute_path?(path)
+            if alpha?(path.getbyte(0)) && path.getbyte(1) == COLON_BYTE
+              SEPARATOR_BYTES.include?(path.getbyte(2))
+            end
+          end
+
+          def alpha?(byte)
+            (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)
+          end
+        else
+          def absolute_path?(path)
+            path.getbyte(0) == SEPARATOR_BYTE
+          end
+        end
+    end
+  end
+end

data/lib/skylight/normalizers/sequel/sql.rb

@@ -0,0 +1,12 @@
+require "skylight/normalizers/sql"
+
+module Skylight
+  module Normalizers
+    module Sequel
+      # Normalizer for SQL requests
+      class SQL < Normalizers::SQL
+        register "sql.sequel"
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/sql.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Skylight
+  module Normalizers
+    # Normalizer for SQL requests
+    class SQL < Normalizer
+      CAT = "db.sql.query"
+
+      # @param trace [Skylight::Messages::Trace::Builder] ignored, only present to match API
+      # @param name [String] ignored, only present to match API
+      # @param payload [Hash]
+      # @option payload [String] [:name] The SQL operation
+      # @option payload [Hash] [:binds] The bound parameters
+      # @return [Array]
+      def normalize(trace, name, payload)
+        case payload[:name]
+        when "SCHEMA", "CACHE"
+          return :skip
+        else
+          name  = CAT
+          title = payload[:name] || "SQL"
+        end
+
+        # We can only handle UTF-8 encoded strings.
+        # (Construction method here avoids extra allocations)
+        sql = String.new.concat("<sk-sql>", payload[:sql], "</sk-sql>").force_encoding(Encoding::UTF_8)
+
+        unless sql.valid_encoding?
+          if config[:log_sql_parse_errors]
+            config.logger.error "[#{Skylight::SqlLexError.formatted_code}] Unable to extract binds from non-UTF-8 query. " \
+                                "encoding=#{payload[:sql].encoding.name} " \
+                                "sql=#{payload[:sql].inspect} "
+          end
+
+          sql = nil
+        end
+
+        [name, title, sql]
+      end
+    end
+  end
+end

data/lib/skylight/probes.rb

@@ -0,0 +1,153 @@
+require "pathname"
+require "active_support/inflector"
+
+module Skylight
+  # @api private
+  module Probes
+    class ProbeRegistration
+      attr_reader :name, :const_name, :require_paths, :probe
+
+      def initialize(name, const_name, require_paths, probe)
+        @name = name
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @probe = probe
+      end
+
+      def install
+        probe.install
+      end
+
+      def constant_available?
+        Skylight::Probes.constant_available?(const_name)
+      end
+    end
+
+    class << self
+      def constant_available?(const_name)
+        ::ActiveSupport::Inflector.safe_constantize(const_name).present?
+      end
+
+      def install!
+        pending = registered.values - installed.values
+
+        pending.each do |registration|
+          if registration.constant_available?
+            install_probe(registration)
+          else
+            register_require_hook(registration)
+          end
+        end
+      end
+
+      def install_probe(registration)
+        return if installed.key?(registration.name)
+
+        installed[registration.name] = registration
+        registration.install
+      end
+
+      def add_path(path)
+        root = Pathname.new(path)
+        Pathname.glob(root.join("./**/*.rb")).each do |f|
+          name = f.relative_path_from(root).sub_ext("").to_s
+          if available.key?(name)
+            raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{f}"
+          end
+
+          available[name] = f
+        end
+      end
+
+      def available
+        @available ||= {}
+      end
+
+      def probe(*probes)
+        unknown = probes.map(&:to_s) - available.keys
+        unless unknown.empty?
+          raise ArgumentError, "unknown probes: #{unknown.join(', ')}"
+        end
+
+        probes.each do |p|
+          require available[p.to_s]
+        end
+      end
+
+      def registered
+        @registered ||= {}
+      end
+
+      def require_hooks
+        @require_hooks ||= {}
+      end
+
+      def installed
+        @installed ||= {}
+      end
+
+      def register(name, *args)
+        if registered.key?(name)
+          raise "already registered: #{name}"
+        end
+
+        registered[name] = ProbeRegistration.new(name, *args)
+
+        true
+      end
+
+      def require_hook(require_path)
+        each_by_require_path(require_path) do |registration|
+          # Double check constant is available
+          if registration.constant_available?
+            install_probe(registration)
+
+            # Don't need this to be called again
+            unregister_require_hook(registration)
+          end
+        end
+      end
+
+      def register_require_hook(registration)
+        registration.require_paths.each do |p|
+          require_hooks[p] ||= []
+          require_hooks[p] << registration
+        end
+      end
+
+      def unregister_require_hook(registration)
+        registration.require_paths.each do |p|
+          require_hooks[p].delete(registration)
+          require_hooks.delete(p) if require_hooks[p].empty?
+        end
+      end
+
+      def each_by_require_path(require_path)
+        return unless require_hooks.key?(require_path)
+
+        # dup because we may be mutating the array
+        require_hooks[require_path].dup.each do |registration|
+          yield registration
+        end
+      end
+    end
+
+    add_path(File.expand_path("./probes", __dir__))
+  end
+end
+
+# @api private
+module Kernel
+  # Unfortunately, we can't use prepend here, in part because RubyGems changes require with an alias
+  alias require_without_sk require
+
+  def require(name)
+    require_without_sk(name).tap do
+      begin
+        Skylight::Probes.require_hook(name)
+      rescue Exception => e # rubocop:disable Lint/SuppressedException
+        warn("[SKYLIGHT] Rescued exception in require hook", e)
+      end
+    end
+  end
+end

data/lib/skylight/probes/action_controller.rb

@@ -0,0 +1,48 @@
+module Skylight
+  module Probes
+    module ActionController
+      class Probe
+        def install
+          # Prepending doesn't work here since this a module that's already been included
+          ::ActionController::Instrumentation.class_eval do
+            private
+
+              alias_method :append_info_to_payload_without_sk, :append_info_to_payload
+              def append_info_to_payload(payload)
+                append_info_to_payload_without_sk(payload)
+
+                payload[:sk_rendered_format] = sk_rendered_mime.try(:ref)
+                payload[:sk_variant] = request.respond_to?(:variant) ? request.variant : nil
+              end
+
+              def sk_rendered_mime
+                if respond_to?(:media_type)
+                  mt = media_type
+                  return mt && Mime::Type.lookup(mt)
+                end
+
+                if content_type.is_a?(Mime::Type)
+                  content_type
+                elsif content_type.respond_to?(:to_s)
+                  type_str = content_type.to_s.split(";").first
+                  Mime::Type.lookup(type_str) unless type_str.blank?
+                elsif respond_to?(:rendered_format) && rendered_format
+                  rendered_format
+                end
+              rescue
+                # There are cases in which actionpack can return
+                # a stringified representation of a Mime::NullType instance,
+                # which is invalid for a number of reasons. This string raises
+                # errors when piped through Mime::Type.lookup, so it's probably
+                # best to just return nil in those cases.
+                nil
+              end
+          end
+        end
+      end
+    end
+
+    register(:action_controller, "ActionController::Instrumentation", "action_controller/metal/instrumentation",
+             ActionController::Probe.new)
+  end
+end

data/lib/skylight/probes/action_dispatch.rb

@@ -0,0 +1,2 @@
+Skylight.probe("action_dispatch/request_id")
+Skylight.probe("action_dispatch/routing/route_set")

data/lib/skylight/probes/action_dispatch/request_id.rb

@@ -0,0 +1,29 @@
+module Skylight
+  module Probes
+    module ActionDispatch
+      module RequestId
+        module Instrumentation
+          def call(env)
+            @skylight_request_id = env["skylight.request_id"]
+            super
+          end
+
+          private
+
+            def internal_request_id
+              @skylight_request_id || super
+            end
+        end
+
+        class Probe
+          def install
+            ::ActionDispatch::RequestId.prepend(Instrumentation)
+          end
+        end
+      end
+    end
+
+    register(:action_dispatch, "ActionDispatch::RequestId", "action_dispatch/middleware/request_id",
+             ActionDispatch::RequestId::Probe.new)
+  end
+end

data/lib/skylight/probes/action_dispatch/routing/route_set.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Skylight
+  module Probes
+    module ActionDispatch
+      module Routing
+        module RouteSet
+          module Instrumentation
+            def call(env)
+              ActiveSupport::Notifications.instrument("route_set.action_dispatch") do
+                super
+              end
+            end
+          end
+
+          class Probe
+            def install
+              ::ActionDispatch::Routing::RouteSet.prepend(Instrumentation)
+            end
+          end
+        end
+      end
+    end
+
+    register(:rails_router, "ActionDispatch::Routing::RouteSet", "action_dispatch/routing/route_set",
+             ActionDispatch::Routing::RouteSet::Probe.new)
+  end
+end

data/lib/skylight/probes/action_view.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Skylight
+  module Probes
+    module ActionView
+      module Instrumentation
+        def render_with_layout(*args) #:nodoc:
+          path, locals = case args.length
+                         when 2
+                           args
+                         when 4
+                           # Rails > 6.0.0.beta3 arguments are (view, template, path, locals)
+                           [args[2], args[3]]
+                         end
+
+          layout = nil
+
+          if path
+            layout = find_layout(path, locals.keys, [formats.first])
+          end
+
+          if layout
+            ActiveSupport::Notifications.instrument("render_template.action_view", identifier: layout.identifier) do
+              super
+            end
+          else
+            super
+          end
+        end
+      end
+
+      class Probe
+        def install
+          return if ::ActionView.gem_version >= Gem::Version.new("6.1.0.alpha")
+
+          ::ActionView::TemplateRenderer.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:action_view, "ActionView::TemplateRenderer", "action_view", ActionView::Probe.new)
+  end
+end