skylight 4.3.2 → 5.0.1

data/lib/skylight/normalizers/grape/endpoint_run_filters.rb

@@ -0,0 +1,22 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class EndpointRunFilters < Endpoint
+        register "endpoint_run_filters.grape"
+
+        CAT = "app.grape.filters".freeze
+
+        def normalize(_trace, _name, payload)
+          filters = payload[:filters]
+          type = payload[:type]
+
+          if (!filters || filters.empty?) || !type
+            return :skip
+          end
+
+          [CAT, "#{type.to_s.capitalize} Filters", nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/grape/format_response.rb

@@ -0,0 +1,20 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class FormatResponse < Normalizer
+        register "format_response.grape"
+
+        CAT = "view.grape.format_response".freeze
+
+        def normalize(_trace, _name, payload)
+          if (formatter = payload[:formatter])
+            title = formatter.is_a?(Module) ? formatter.to_s : formatter.class.to_s
+            [CAT, title, nil]
+          else
+            :skip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/graphiti/render.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Skylight
+  module Normalizers
+    module Graphiti
+      class Render < Normalizer
+        register "render.graphiti"
+
+        CAT = "view.render.graphiti"
+        ANONYMOUS = "<Anonymous Resource>"
+
+        def normalize(_trace, _name, payload)
+          resource_class = payload[:proxy]&.resource&.class
+          title = "Render #{resource_class&.name || ANONYMOUS}"
+          desc = nil
+
+          [CAT, title, desc]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/graphiti/resolve.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Skylight
+  module Normalizers
+    module Graphiti
+      class Resolve < Normalizer
+        register "resolve.graphiti"
+
+        CAT = "app.resolve.graphiti"
+
+        ANONYMOUS_RESOURCE = "<Anonymous Resource>"
+        ANONYMOUS_ADAPTER = "<Anonymous Adapter>"
+
+        def normalize(_trace, _name, payload)
+          resource = payload[:resource]
+
+          if (sideload = payload[:sideload])
+            type = sideload.type.to_s.split("_").map(&:capitalize).join(" ")
+            desc = "Custom Scope" if sideload.class.scope_proc
+          else
+            type = "Primary"
+          end
+
+          title = "Resolve #{type} #{resource.class.name || ANONYMOUS_RESOURCE}"
+
+          [CAT, title, desc]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/graphql/base.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module Skylight::Normalizers::GraphQL
+  # Some AS::N events in GraphQL are not super useful.
+  # We are purposefully ignoring the following keys (and you probably shouldn't add them):
+  #  - "graphql.analyze_multiplex"
+  #  - "graphql.execute_field" (very frequently called)
+  #  - "graphql.execute_field_lazy"
+
+  class Base < Skylight::Normalizers::Normalizer
+    ANONYMOUS = "[anonymous]"
+    CAT = "app.graphql"
+
+    if defined?(::GraphQL::VERSION) && Gem::Version.new(::GraphQL::VERSION) >= Gem::Version.new("1.10")
+      def self.register_graphql
+        register("#{key}.graphql")
+      end
+    else
+      def self.register_graphql
+        register("graphql.#{key}")
+      end
+    end
+
+    def self.inherited(klass)
+      super
+      klass.const_set(
+        :KEY,
+        ActiveSupport::Inflector.underscore(
+          ActiveSupport::Inflector.demodulize(klass.name)
+        ).freeze
+      )
+    end
+
+    def self.key
+      self::KEY
+    end
+
+    def normalize(_trace, _name, _payload)
+      [CAT, "graphql.#{key}", nil]
+    end
+
+    private
+
+      def key
+        self.class.key
+      end
+
+      def extract_query_name(query)
+        query&.context&.[](:skylight_endpoint) ||
+          query&.operation_name ||
+          ANONYMOUS
+      end
+  end
+
+  class Lex < Base
+    register_graphql
+  end
+
+  class Parse < Base
+    register_graphql
+  end
+
+  class Validate < Base
+    register_graphql
+  end
+
+  class ExecuteMultiplex < Base
+    register_graphql
+
+    def normalize_after(trace, _span, _name, payload)
+      # This is in normalize_after because the queries may not have
+      # an assigned operation name before they are executed.
+      # For example, if you send a single query with a defined operation name, e.g.:
+      # ```graphql
+      #   query MyNamedQuery { user(id: 1) { name } }
+      # ```
+      # ... but do _not_ send the operationName request param, the GraphQL docs[1]
+      # specify that the executor should use the operation name from the definition.
+      #
+      # In graphql-ruby's case, the calculation of the operation name is lazy, and
+      # has not been done yet at the point where execute_multiplex starts.
+      # [1] https://graphql.org/learn/serving-over-http/#post-request
+      queries, has_errors = payload[:multiplex].queries.each_with_object([Set.new, Set.new]) do |query, (names, errors)|
+        names << extract_query_name(query)
+        errors << query.static_errors.any?
+      end
+
+      trace.endpoint = "graphql:#{queries.sort.join('+')}"
+      trace.compound_response_error_status = if has_errors.all?
+                                               :all
+                                             elsif has_errors.any?
+                                               :partial
+                                             end
+    end
+  end
+
+  class AnalyzeQuery < Base
+    register_graphql
+  end
+
+  class ExecuteQuery < Base
+    register_graphql
+
+    def normalize(trace, _name, payload)
+      query_name = extract_query_name(payload[:query])
+
+      if query_name == ANONYMOUS
+        meta = { mute_children: true }
+      end
+
+      # This is probably always overriden by execute_multiplex#normalize_after,
+      # but in the case of a single query, it will be the same value anyway.
+      trace.endpoint = "graphql:#{query_name}"
+
+      [CAT, "graphql.#{key}: #{query_name}", nil, meta]
+    end
+  end
+
+  class ExecuteQueryLazy < ExecuteQuery
+    register_graphql
+
+    def normalize(trace, _name, payload)
+      if payload[:query]
+        super
+      elsif payload[:multiplex]
+        [CAT, "graphql.#{key}.multiplex", nil]
+      end
+    end
+  end
+end

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/shrine.rb

@@ -0,0 +1,34 @@
+module Skylight
+  module Normalizers
+    class Shrine < Normalizer
+      TITLES = {
+        "upload.shrine"           => "Upload",
+        "download.shrine"         => "Download",
+        "open.shrine"             => "Open",
+        "exists.shrine"           => "Exists",
+        "delete.shrine"           => "Delete",
+        "metadata.shrine"         => "Metadata",
+        "mime_type.shrine"        => "MIME Type",
+        "image_dimensions.shrine" => "Image Dimensions",
+        "signature.shrine"        => "Signature",
+        "extension.shrine"        => "Extension",
+        "derivation.shrine"       => "Derivation",
+        "derivatives.shrine"      => "Derivatives",
+        "data_uri.shrine"         => "Data URI",
+        "remote_url.shrine"       => "Remote URL"
+      }.freeze
+
+      TITLES.each_key do |key|
+        register key
+      end
+
+      def normalize(_trace, name, _payload)
+        title = ["Shrine", TITLES[name]].join(" ")
+
+        cat = "app.#{name.split('.').reverse.join('.')}"
+
+        [cat, title, nil]
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/sql.rb

@@ -0,0 +1,45 @@
+# 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,181 @@
+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
+      rescue StandardError, LoadError => e
+        log_install_exception(e)
+      end
+
+      def constant_available?
+        Skylight::Probes.constant_available?(const_name)
+      end
+
+      private
+
+        def log_install_exception(err)
+          description = err.class.to_s
+          description << ": #{err.message}" unless err.message.empty?
+
+          backtrace = err.backtrace.map { |l| "  #{l}" }.join("\n")
+
+          gems =
+            begin
+              Bundler.locked_gems.dependencies.map { |d| [d.name, d.requirement.to_s] }
+            rescue # rubocop:disable Lint/SuppressedException
+            end
+
+          error = "[SKYLIGHT] [#{Skylight::VERSION}] Encountered an error while installing the " \
+                          "probe for #{const_name}. Please notify support@skylight.io with the debugging " \
+                          "information below. It's recommended that you disable this probe until the " \
+                          "issue is resolved." \
+                          "\n\nERROR: #{description}\n\n#{backtrace}\n\n"
+
+          if gems
+            gems_string = gems.map { |g| "  #{g[0]}   #{g[1]}" }.join("\n")
+            error << "GEMS:\n\n#{gems_string}\n\n"
+          end
+
+          $stderr.puts(error)
+        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
+          next unless registration.constant_available?
+
+          install_probe(registration)
+
+          # Don't need this to be called again
+          unregister_require_hook(registration)
+        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
+      Skylight::Probes.require_hook(name)
+    rescue Exception => e
+      warn("[SKYLIGHT] Rescued exception in require hook", e)
+    end
+  end
+end