skylight 4.2.3 → 5.3.0

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")

data/lib/skylight/probes/action_view.rb

@@ -0,0 +1,42 @@
+# 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
+
+          layout = find_layout(path, locals.keys, [formats.first]) if path
+
+          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

data/lib/skylight/probes/active_job.rb

@@ -0,0 +1,27 @@
+module Skylight
+  module Probes
+    module ActiveJob
+      TITLE = "ActiveJob.execute".freeze
+
+      module Instrumentation
+        def execute(*)
+          Skylight.trace(TITLE, "app.job.execute", component: :worker) do |trace|
+            # See normalizers/active_job/perform for endpoint/segment assignment
+            super
+          rescue Exception
+            trace.segment = "error" if trace
+            raise
+          end
+        end
+      end
+
+      class Probe
+        def install
+          ::ActiveJob::Base.singleton_class.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:active_job, "ActiveJob::Base", "active_job/base", ActiveJob::Probe.new)
+  end
+end

data/lib/skylight/probes/active_job_enqueue.rb

@@ -0,0 +1,35 @@
+module Skylight
+  module Probes
+    module ActiveJob
+      class EnqueueProbe
+        CAT = "other.active_job.enqueue".freeze
+
+        def install
+          ::ActiveJob::Base.around_enqueue do |job, block|
+            job_class = job.class
+            adapter_name = EnqueueProbe.normalize_adapter_name(job_class)
+
+            # If this is an ActionMailer::DeliveryJob, we'll report this as the mailer title
+            # and include ActionMailer::DeliveryJob in the description.
+            name, job_class_name = Normalizers::ActiveJob::Perform.normalize_title(job)
+            descriptors = ["adapter: '#{adapter_name}'", "queue: '#{job.queue_name}'"]
+            descriptors << "job: '#{job_class_name}'" if job_class_name
+            desc = "{ #{descriptors.join(", ")} }"
+          rescue StandardError
+            block.call
+          else
+            Skylight.instrument(title: "Enqueue #{name}", category: CAT, description: desc, internal: true, &block)
+          end
+
+          self.class.instance_eval do
+            def normalize_adapter_name(job_class)
+              job_class.queue_adapter_name
+            end
+          end
+        end
+      end
+    end
+
+    register(:active_job_enqueue, "ActiveJob::Base", "active_job/base", ActiveJob::EnqueueProbe.new)
+  end
+end

data/lib/skylight/probes/active_model_serializers.rb

@@ -0,0 +1,50 @@
+module Skylight
+  module Probes
+    module ActiveModelSerializers
+      module Instrumentation
+        def as_json(*)
+          payload = { serializer: self.class }
+          ActiveSupport::Notifications.instrument("render.active_model_serializers", payload) { super }
+        end
+      end
+
+      class Probe
+        def install
+          version = nil
+
+          # File moved location between version
+          %w[serializer serializers].each do |dir|
+            require "active_model/#{dir}/version"
+          rescue LoadError # rubocop:disable Lint/SuppressedException
+          end
+
+          version = Gem.loaded_specs["active_model_serializers"].version if Gem.loaded_specs["active_model_serializers"]
+
+          if !version || version < Gem::Version.new("0.5.0")
+            Skylight.error "Instrumention is only available for ActiveModelSerializers version 0.5.0 and greater."
+            return
+          end
+
+          # We don't actually support the RCs correctly, requires
+          # a release after 0.10.0.rc3
+          if version >= Gem::Version.new("0.10.0.rc1")
+            # AS::N is built in to newer versions
+            return
+          end
+
+          # End users could override as_json without calling super, but it's likely safer
+          # than overriding serializable_array/hash/object.
+
+          [::ActiveModel::Serializer, ::ActiveModel::ArraySerializer].each { |klass| klass.prepend(Instrumentation) }
+        end
+      end
+    end
+
+    register(
+      :active_model_serializers,
+      "ActiveModel::Serializer",
+      "active_model/serializer",
+      ActiveModelSerializers::Probe.new
+    )
+  end
+end