skylight 4.3.2 → 5.0.1

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

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,41 @@
+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
+            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
+
+          if Gem.loaded_specs["active_model_serializers"]
+            version = Gem.loaded_specs["active_model_serializers"].version
+          end
+
+          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 do |klass|
+            klass.prepend(Instrumentation)
+          end
+        end
+      end
+    end
+
+    register(:active_model_serializers, "ActiveModel::Serializer", "active_model/serializer",
+             ActiveModelSerializers::Probe.new)
+  end
+end

data/lib/skylight/probes/delayed_job.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Skylight
+  module Probes
+    module DelayedJob
+      begin
+        require "delayed/plugin"
+
+        class Plugin < ::Delayed::Plugin
+          callbacks do |lifecycle|
+            lifecycle.around(:perform) do |worker, job, &block|
+              sk_instrument(worker, job, &block)
+            end
+
+            lifecycle.after(:error) do |_worker, _job|
+              Skylight.trace&.segment = "error"
+            end
+          end
+
+          class << self
+            include Skylight::Util::Logging
+
+            def sk_instrument(_worker, job)
+              endpoint = Skylight::Probes::DelayedJob.handler_name(job)
+
+              Skylight.trace(endpoint,
+                             "app.delayed_job.worker",
+                             "Delayed::Worker#run",
+                             component: :worker,
+                             segment:   job.queue,
+                             meta:      { source_location: "delayed_job" }) do
+                               t { "Delayed::Job beginning trace" }
+                               yield
+                             end
+            end
+          end
+        end
+      rescue LoadError
+        $stderr.puts "[SKYLIGHT] The delayed_job probe was requested, but Delayed::Plugin was not defined."
+      end
+
+      UNKNOWN = "<Delayed::Job Unknown>"
+
+      def self.handler_name(job)
+        payload_object = if job.respond_to?(:payload_object_without_sk)
+                           job.payload_object_without_sk
+                         else
+                           job.payload_object
+                         end
+
+        payload_object_name(payload_object)
+      end
+
+      def self.payload_object_name(payload_object)
+        if payload_object.is_a?(::Delayed::PerformableMethod)
+          payload_object.display_name
+        else
+          # In the case of ActiveJob-wrapped jobs, there is quite a bit of job-specific metadata
+          # in `job.name`, which would break aggregation and potentially leak private data in job args.
+          # Use class name instead to avoid this.
+          payload_object.class.name
+        end
+      rescue
+        UNKNOWN
+      end
+
+      def self.payload_object_source_meta(payload_object)
+        if payload_object.is_a?(::Delayed::PerformableMethod)
+          if payload_object.object.is_a?(Module)
+            [:class_method, payload_object.object.name, payload_object.method_name.to_s]
+          else
+            [:instance_method, payload_object.object.class.name, payload_object.method_name.to_s]
+          end
+        else
+          [:instance_method, payload_object.class.name, "perform"]
+        end
+      end
+
+      class InstrumentationProxy < SimpleDelegator
+        def perform
+          source_meta = Skylight::Probes::DelayedJob.payload_object_source_meta(__getobj__)
+
+          opts = {
+            category: "app.delayed_job.job",
+            title:    format_source(*source_meta),
+            meta:     { source_location_hint: source_meta },
+            internal: true
+          }
+
+          Skylight.instrument(opts) { __getobj__.perform }
+        end
+
+        # Used by Delayed::Backend::Base to determine Job#name
+        def display_name
+          __getobj__.respond_to?(:display_name) ? __getobj__.display_name : __getobj__.class.name
+        end
+
+        private
+
+          def format_source(method_type, constant_name, method_name)
+            if method_type == :instance_method
+              "#{constant_name}##{method_name}"
+            else
+              "#{constant_name}.#{method_name}"
+            end
+          end
+      end
+
+      class Probe
+        def install
+          return unless validate_version && plugin_defined?
+
+          ::Delayed::Worker.plugins = [Skylight::Probes::DelayedJob::Plugin] | ::Delayed::Worker.plugins
+          ::Delayed::Backend::Base.class_eval do
+            alias_method :payload_object_without_sk, :payload_object
+
+            def payload_object
+              Skylight::Probes::DelayedJob::InstrumentationProxy.new(payload_object_without_sk)
+            end
+          end
+        end
+
+        private
+
+          def plugin_defined?
+            defined?(::Skylight::Probes::DelayedJob::Plugin)
+          end
+
+          def validate_version
+            spec = Gem.loaded_specs["delayed_job"]
+            version = spec&.version
+
+            if !version || version < Gem::Version.new("4.0.0")
+              Skylight.error "The installed version of DelayedJob is not supported on Skylight. " \
+                             "Your jobs will not be tracked."
+
+              return false
+            end
+
+            true
+          end
+      end
+    end
+
+    register(:delayed_job, "Delayed::Worker", "delayed_job", DelayedJob::Probe.new)
+  end
+end

data/lib/skylight/probes/elasticsearch.rb

@@ -0,0 +1,38 @@
+module Skylight
+  module Probes
+    module Elasticsearch
+      class Probe
+        def install
+          # Prepending doesn't work here since this a module that's already been included
+          ::Elasticsearch::Transport::Transport::Base.class_eval do
+            alias_method :perform_request_without_sk, :perform_request
+            def perform_request(method, path, *args, &block)
+              ActiveSupport::Notifications.instrument(
+                "request.elasticsearch",
+                name:   "Request",
+                method: method,
+                path:   path
+              ) do
+                # Prevent HTTP-related probes from firing
+                Skylight::Normalizers::Faraday::Request.disable do
+                  disable_skylight_probe(:NetHTTP) do
+                    disable_skylight_probe(:HTTPClient) do
+                      perform_request_without_sk(method, path, *args, &block)
+                    end
+                  end
+                end
+              end
+            end
+
+            def disable_skylight_probe(class_name)
+              klass = ::ActiveSupport::Inflector.safe_constantize("Skylight::Probes::#{class_name}::Probe")
+              (klass ? klass.disable { yield } : yield).tap { Skylight.log(:debug, "re-enabling: #{klass}") }
+            end
+          end
+        end
+      end
+    end
+
+    register(:elasticsearch, "Elasticsearch", "elasticsearch", Elasticsearch::Probe.new)
+  end
+end