skylight 3.1.4 → 5.3.4

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,41 @@
+# 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)
+        return :skip if payload[:name] == "SCHEMA" || payload[:name] == "CACHE"
+
+        title = payload[:name] || "SQL"
+
+        # 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
+
+        [CAT, title, sql]
+      end
+    end
+  end
+end

data/lib/skylight/normalizers.rb

@@ -0,0 +1,157 @@
+module Skylight
+  # @api private
+  # Convert AS::N events to Skylight events
+  module Normalizers
+    def self.registry
+      @registry ||= {}
+    end
+
+    def self.register(name, klass, opts = {})
+      enabled = opts[:enabled] != false
+      registry[name] = [klass, enabled]
+    end
+
+    def self.unregister(name)
+      @registry.delete(name)
+    end
+
+    def self.enable(*names, enabled: true)
+      names.each do |name|
+        matches = registry.select { |n, _| n =~ /(^|\.)#{name}$/ }
+        raise ArgumentError, "no normalizers match #{name}" if matches.empty?
+
+        matches.each_value { |v| v[1] = enabled }
+      end
+    end
+
+    def self.disable(*names)
+      enable(*names, enabled: false)
+    end
+
+    def self.build(config)
+      normalizers = {}
+
+      registry.each do |key, (klass, enabled)|
+        next unless enabled
+
+        unless klass.method_defined?(:normalize)
+          # TODO: Warn
+          next
+        end
+
+        normalizers[key] = klass.new(config)
+      end
+
+      Container.new(normalizers)
+    end
+
+    class Normalizer
+      def self.register(name, opts = {})
+        Normalizers.register(name, self, opts)
+      end
+
+      attr_reader :config
+
+      include Util::Logging
+
+      def initialize(config)
+        @config = config
+        setup if respond_to?(:setup)
+      end
+
+      def normalize(_trace, _name, _payload)
+        :skip
+      end
+
+      def normalize_with_meta(trace, name, payload)
+        # If we have a normal response but no meta, add it
+        cat, title, desc, meta = ret = normalize(trace, name, payload)
+        return cat if cat == :skip
+
+        meta ||= {}
+        cache_key = ret.hash
+        process_meta(trace, name, payload, meta, cache_key: cache_key)
+
+        [cat, title, desc, meta]
+      end
+
+      def normalize_after(trace, span, name, payload); end
+
+      private
+
+      def process_meta(trace, _name, payload, meta, cache_key: nil)
+        trace.instrumenter.extensions.process_normalizer_meta(
+          payload,
+          meta,
+          cache_key: cache_key,
+          **process_meta_options(payload)
+        )
+      end
+
+      def process_meta_options(_payload)
+        {}
+      end
+    end
+
+    require "skylight/normalizers/default"
+    DEFAULT = Default.new
+
+    class Container
+      def initialize(normalizers)
+        @normalizers = normalizers
+      end
+
+      def keys
+        @normalizers.keys
+      end
+
+      def each_key(&block)
+        @normalizers.each_key(&block)
+      end
+
+      def normalize(trace, name, payload)
+        normalizer_for(name).normalize_with_meta(trace, name, payload)
+      end
+
+      def normalize_after(trace, span, name, payload)
+        normalizer_for(name).normalize_after(trace, span, name, payload)
+      end
+
+      def normalizer_for(name)
+        # We never expect to hit the default case since we only register listeners
+        # for items that we know have normalizers. For now, though, we'll play it
+        # safe and provide a fallback.
+        @normalizers.fetch(name, DEFAULT)
+      end
+    end
+
+    %w[
+      action_controller/process_action
+      action_controller/send_file
+      action_dispatch/process_middleware
+      action_dispatch/route_set
+      action_view/render_collection
+      action_view/render_partial
+      action_view/render_template
+      action_view/render_layout
+      active_job/perform
+      active_model_serializers/render
+      active_record/instantiation
+      active_record/sql
+      active_storage
+      active_support/cache
+      coach/handler_finish
+      coach/middleware_finish
+      couch_potato/query
+      data_mapper/sql
+      elasticsearch/request
+      faraday/request
+      grape/endpoint
+      graphiti/resolve
+      graphiti/render
+      graphql/base
+      sequel/sql
+      shrine
+    ].each { |file| require "skylight/normalizers/#{file}" }
+  end
+end

data/lib/skylight/probes/action_controller.rb

@@ -0,0 +1,52 @@
+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 StandardError
+              # 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/request_id.rb

@@ -0,0 +1,33 @@
+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,30 @@
+# 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") { super }
+            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_dispatch.rb

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