skylight 4.3.2 → 5.1.1

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

@@ -0,0 +1,39 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class EndpointRun < Endpoint
+        register "endpoint_run.grape"
+
+        def normalize(trace, _name, payload)
+          trace.endpoint = get_endpoint_name(payload[:endpoint]) if payload[:endpoint]
+
+          # We don't necessarily want this to be all instrumented since it's fairly internal.
+          # However, it is a good place to get the endpoint name.
+          :skip
+        end
+
+        private
+
+        def get_endpoint_name(endpoint)
+          method = get_method(endpoint)
+          path = get_path(endpoint)
+          namespace = get_namespace(endpoint)
+
+          if namespace && !namespace.empty?
+            path = "/#{path}" if path[0] != "/"
+            path = "#{namespace}#{path}"
+          end
+
+          "#{base_app_name(endpoint)} [#{method}] #{path}".strip
+        end
+
+        def base_app_name(endpoint)
+          ep = endpoint.options[:for]
+          return ep.name if ep.name
+
+          ep.base.name if ep.respond_to?(:base) && ep.base.respond_to?(:name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+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]
+
+          return :skip if (!filters || filters.empty?) || !type
+
+          [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,127 @@
+# 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])
+
+      meta = { mute_children: true } if query_name == ANONYMOUS
+
+      # 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,79 @@
+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)
+          SEPARATOR_BYTES.include?(path.getbyte(2)) if alpha?(path.getbyte(0)) && path.getbyte(1) == COLON_BYTE
+        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,32 @@
+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 { |key| register key }
+
+      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,173 @@
+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")
+
+        # rubocop:disable Lint/SuppressedException
+        gems =
+          begin
+            Bundler.locked_gems.dependencies.map { |d| [d.name, d.requirement.to_s] }
+          rescue StandardError
+          end
+
+        # rubocop:enable Lint/SuppressedException
+
+        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|
+          registration.constant_available? ? install_probe(registration) : register_require_hook(registration)
+        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
+            raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{f}" if available.key?(name)
+
+            available[name] = f
+          end
+      end
+
+      def available
+        @available ||= {}
+      end
+
+      def probe(*probes)
+        unknown = probes.map(&:to_s) - available.keys
+        raise ArgumentError, "unknown probes: #{unknown.join(", ")}" unless unknown.empty?
+
+        probes.each { |p| require available[p.to_s] }
+      end
+
+      def registered
+        @registered ||= {}
+      end
+
+      def require_hooks
+        @require_hooks ||= {}
+      end
+
+      def installed
+        @installed ||= {}
+      end
+
+      def register(name, *args)
+        raise "already registered: #{name}" if registered.key?(name)
+
+        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 { |registration| yield registration }
+      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