skylight 3.1.4 → 5.3.4

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

data/lib/skylight/probes/active_record_async.rb

@@ -0,0 +1,96 @@
+module Skylight
+  module Probes
+    module ActiveRecord
+      module FutureResult
+        # Applied to ActiveSupport::Notifications::Event
+        module AsyncEventExtensions
+          # Notify Skylight that the event has started
+          def __sk_start!
+            subscriber = Skylight.instrumenter.subscriber
+            subscriber.start(name, nil, payload)
+            trace = Skylight.instrumenter.current_trace
+
+            # Set a finisher to end the event
+            @__sk_finisher = ->(name, payload) do
+              subscriber.with_trace(trace) { subscriber.finish(name, nil, payload) }
+            end
+
+            # End it immediately if we've actually already ended
+            __sk_finish! if @end
+          rescue StandardError => e
+            Skylight.error("Unable to start event for FutureResult: #{e}")
+          end
+
+          # Notify Skylight that the event has finished
+          def __sk_finish!
+            return unless @__sk_finisher
+
+            @__sk_finisher.call(name, payload)
+            @__sk_finisher = nil
+          rescue StandardError => e
+            Skylight.error("Unable to finish event for FutureResult: #{e}")
+          end
+
+          # When the event is marked as finish make sure we notify Skylight
+          def finish!
+            super
+            __sk_finish!
+          end
+        end
+
+        # Applied to FutureResult
+        module Instrumentation
+          def result(*, **)
+            # This instruments the whole FutureResult so that we know when we were executing (potenially) async.
+            ActiveSupport::Notifications.instrument("future_result.active_record", { args: @args, kwargs: @kwargs }) do
+              super
+            end
+          end
+
+          private
+
+          def execute_or_wait(*, **)
+            # At this point we're actually waiting for the query to have finished executing.
+
+            begin
+              # If the query has already started async, the @event_buffer will be defined.
+              # We grab the events (currently only the SQL queries), extend them with our
+              # special methods and notify Skylight.
+              # We act as if the event has just stared, though the query may already have been
+              # running. This means we're essentially just logging blocking time right now.
+
+              # Dup here just in case more get added somehow during the super call
+              events = @event_buffer&.instance_variable_get(:@events).dup
+
+              events&.each do |event|
+                event.singleton_class.prepend(AsyncEventExtensions)
+                event.__sk_start!
+              end
+            rescue StandardError => e
+              Skylight.error("Unable to start events for FutureResult: #{e}")
+            end
+
+            super
+          ensure
+            # Once we've actually got a result, we mark each one as finished.
+            # Note that it may have already finished, but if it didn't we need to say so now.
+            events&.reverse_each(&:__sk_finish!)
+          end
+        end
+
+        class Probe
+          def install
+            ::ActiveRecord::FutureResult.prepend(Instrumentation)
+          end
+        end
+      end
+    end
+
+    register(
+      :active_record_async,
+      "ActiveRecord::FutureResult",
+      "active_record/future_result",
+      ActiveRecord::FutureResult::Probe.new
+    )
+  end
+end

data/lib/skylight/probes/delayed_job.rb

@@ -0,0 +1,144 @@
+# 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) { |worker, job, &block| sk_instrument(worker, job, &block) }
+
+            lifecycle.after(:error) { |_worker, _job| Skylight.trace&.segment = "error" }
+          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 =
+          job.respond_to?(:payload_object_without_sk) ? job.payload_object_without_sk : job.payload_object
+
+        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 StandardError
+        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)
+          method_type == :instance_method ? "#{constant_name}##{method_name}" : "#{constant_name}.#{method_name}"
+        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,45 @@
+module Skylight
+  module Probes
+    module Elasticsearch
+      class Probe
+        def install
+          const =
+            if defined?(::Elasticsearch::Transport::Transport::Base)
+              ::Elasticsearch::Transport::Transport::Base
+            elsif defined?(::Elastic::Transport::Transport::Base)
+              ::Elastic::Transport::Transport::Base
+            else
+              return false
+            end
+
+          # Prepending doesn't work here since this a module that's already been included
+          const.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) { perform_request_without_sk(method, path, *args, &block) }
+                  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

data/lib/skylight/probes/excon/middleware.rb

@@ -0,0 +1,65 @@
+require "skylight/formatters/http"
+
+module Skylight
+  module Probes
+    module Excon
+      # Middleware for Excon that instruments requests
+      class Middleware < ::Excon::Middleware::Base
+        def initialize(*)
+          @requests = {}.compare_by_identity
+          super
+        end
+
+        # TODO: Review the following:
+        # - Consider whether a LIFO queue would be sufficient
+        # - Check that errors can't be called without a request
+
+        def request_call(datum)
+          begin_instrumentation(datum)
+          super
+        end
+
+        def response_call(datum)
+          super
+        ensure
+          end_instrumentation(datum)
+        end
+
+        def error_call(datum)
+          super
+        ensure
+          end_instrumentation(datum)
+        end
+
+        private
+
+        def begin_instrumentation(datum)
+          method = datum[:method].to_s
+          scheme = datum[:scheme]
+          host = datum[:host]
+
+          # TODO: Maybe don't show other default ports like 443
+          port = datum[:port] == 80 ? nil : datum[:port]
+          path = datum[:path]
+          query = datum[:query]
+
+          opts = Formatters::HTTP.build_opts(method, scheme, host, port, path, query)
+
+          @requests[datum] = Skylight.instrument(opts)
+        rescue Exception => e
+          Skylight.error "failed to begin instrumentation for Excon; msg=%s", e.message
+        end
+
+        def end_instrumentation(datum)
+          if (request = @requests.delete(datum))
+            meta = {}
+            meta[:exception_object] = datum[:error] if datum[:error].is_a?(Exception)
+            Skylight.done(request, meta)
+          end
+        rescue Exception => e
+          Skylight.error "failed to end instrumentation for Excon; msg=%s", e.message
+        end
+      end
+    end
+  end
+end

data/lib/skylight/probes/excon.rb

@@ -0,0 +1,25 @@
+module Skylight
+  module Probes
+    module Excon
+      # Probe for instrumenting Excon requests. Installs {Excon::Middleware} to achieve this.
+      class Probe
+        def install
+          if defined?(::Excon::Middleware)
+            # Don't require until installation since it depends on Excon being loaded
+            require "skylight/probes/excon/middleware"
+
+            idx = ::Excon.defaults[:middlewares].index(::Excon::Middleware::Instrumentor)
+
+            # TODO: Handle possibility of idx being nil
+            ::Excon.defaults[:middlewares].insert(idx, Probes::Excon::Middleware)
+          else
+            Skylight.error "The installed version of Excon doesn't support Middlewares. " \
+                             "The Excon probe will be disabled."
+          end
+        end
+      end
+    end
+
+    register(:excon, "Excon", "excon", Excon::Probe.new)
+  end
+end

data/lib/skylight/probes/faraday.rb

@@ -0,0 +1,23 @@
+module Skylight
+  module Probes
+    module Faraday
+      module Instrumentation
+        def builder
+          unless defined?(@__sk__setup)
+            @__sk__setup = true
+            @builder.insert 0, ::Faraday::Request::Instrumentation
+          end
+          @builder
+        end
+      end
+
+      class Probe
+        def install
+          ::Faraday::Connection.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:faraday, "Faraday", "faraday", Faraday::Probe.new)
+  end
+end

data/lib/skylight/probes/graphql.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module Skylight
+  module Probes
+    module GraphQL
+      module Instrumentation
+        def initialize(*, **)
+          super
+
+          return unless defined?(@tracers)
+
+          unless @tracers.include?(::GraphQL::Tracing::ActiveSupportNotificationsTracing)
+            @tracers << ::GraphQL::Tracing::ActiveSupportNotificationsTracing
+          end
+        end
+      end
+
+      class Probe
+        def install
+          tracing_klass_name = "::GraphQL::Tracing::ActiveSupportNotificationsTracing"
+          klasses_to_probe = %w[::GraphQL::Execution::Multiplex ::GraphQL::Query]
+
+          return unless ([tracing_klass_name] + klasses_to_probe).all?(&method(:safe_constantize))
+
+          klasses_to_probe.each { |klass_name| safe_constantize(klass_name).prepend(Instrumentation) }
+        end
+
+        def safe_constantize(klass_name)
+          ActiveSupport::Inflector.safe_constantize(klass_name)
+        end
+      end
+    end
+
+    register(:graphql, "GraphQL", "graphql", GraphQL::Probe.new)
+  end
+end

data/lib/skylight/probes/httpclient.rb

@@ -0,0 +1,44 @@
+require "skylight/formatters/http"
+
+module Skylight
+  module Probes
+    module HTTPClient
+      module Instrumentation
+        # HTTPClient has request methods on the class object itself,
+        # but they internally instantiate a client and perform the method
+        # on that, so this instance method override will cover both
+        # `HTTPClient.get(...)` and `HTTPClient.new.get(...)`
+
+        def do_request(method, uri, *)
+          return super if Probes::HTTPClient::Probe.disabled?
+
+          opts = Formatters::HTTP.build_opts(method, uri.scheme, uri.host, uri.port, uri.path, uri.query)
+
+          Skylight.instrument(opts) { super }
+        end
+      end
+
+      class Probe
+        DISABLED_KEY = :__skylight_httpclient_disabled
+
+        def self.disable
+          old_value = Thread.current[DISABLED_KEY]
+          Thread.current[DISABLED_KEY] = true
+          yield
+        ensure
+          Thread.current[DISABLED_KEY] = old_value
+        end
+
+        def self.disabled?
+          !!Thread.current[DISABLED_KEY]
+        end
+
+        def install
+          ::HTTPClient.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:httpclient, "HTTPClient", "httpclient", HTTPClient::Probe.new)
+  end
+end