skylight 4.2.3 → 5.3.0

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,36 @@
+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) { 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

data/lib/skylight/probes/middleware.rb

@@ -0,0 +1,135 @@
+module Skylight
+  module Probes
+    module Middleware
+      # for Rails >= 6.0, which includes InstrumentationProxy
+      module InstrumentationExtensions
+        def initialize(middleware, class_name)
+          super
+
+          # NOTE: Caching here leads to better performance, but will not notice if the method is overridden
+          # We don't have access to the config here so we can't check whether source locations are enabled.
+          # However, this only happens once per middleware so it should be minimal impact.
+          @payload[:sk_source_location] =
+            begin
+              if middleware.is_a?(Proc)
+                middleware.source_location
+              elsif middleware.respond_to?(:call)
+                middleware.method(:call).source_location
+              end
+            rescue StandardError
+              nil
+            end
+        end
+      end
+
+      # for Rails <= 5.2 ActionDispatch::MiddlewareStack::Middleware
+      module Instrumentation
+        def build(*)
+          Instrumentation.sk_instrument_middleware(super)
+        end
+
+        def self.sk_instrument_middleware(middleware)
+          return middleware if middleware.is_a?(Skylight::Middleware)
+
+          # Not sure how this would actually happen
+          return middleware if middleware.respond_to?(:__has_sk__)
+
+          # On Rails 3, ActionDispatch::Session::CookieStore is frozen, for one
+          return middleware if middleware.frozen?
+
+          Skylight::Probes::Middleware::Probe.add_instrumentation(middleware)
+
+          middleware
+        end
+      end
+
+      class Probe
+        DISABLED_KEY = :__skylight_middleware_disabled
+
+        def self.disable!
+          @disabled = true
+        end
+
+        def self.enable!
+          @disabled = false
+        end
+
+        def self.disabled?
+          !!@disabled
+        end
+
+        module InstanceInstrumentation
+          def call(*args)
+            return super(*args) if Skylight::Probes::Middleware::Probe.disabled?
+
+            trace = Skylight.instrumenter&.current_trace
+            return super(*args) unless trace
+
+            begin
+              name = self.class.name || __sk_default_name
+
+              trace.endpoint = name
+
+              source_file, source_line = method(__method__).super_method.source_location
+
+              spans =
+                Skylight.instrument(
+                  title: name,
+                  category: __sk_category,
+                  source_file: source_file,
+                  source_line: source_line
+                )
+
+              proxied_response =
+                Skylight::Middleware.with_after_close(super(*args), debug_identifier: "Middleware: #{name}") do
+                  Skylight.done(spans)
+                end
+            rescue Exception => e
+              Skylight.done(spans, exception_object: e)
+              raise
+            ensure
+              unless e || proxied_response
+                # If we've gotten to this point, the most likely scenario is that
+                # a throw/catch has bypassed a portion of the callstack. Since these spans would not otherwise
+                # be closed, mark them deferred to indicate that they should be implicitly closed.
+                # See Trace#deferred_spans or Trace#stop for more information.
+                Skylight.done(spans, defer: true)
+              end
+            end
+          end
+
+          def __sk_default_name
+            "Anonymous Middleware"
+          end
+
+          def __sk_category
+            "rack.middleware"
+          end
+
+          def __has_sk__
+            true
+          end
+        end
+
+        def self.add_instrumentation(middleware)
+          middleware.singleton_class.prepend(InstanceInstrumentation)
+        end
+
+        def install
+          if defined?(::ActionDispatch::MiddlewareStack::InstrumentationProxy)
+            ::ActionDispatch::MiddlewareStack::InstrumentationProxy.prepend(InstrumentationExtensions)
+          else
+            ::ActionDispatch::MiddlewareStack::Middleware.prepend(Instrumentation)
+          end
+        end
+      end
+    end
+
+    register(
+      :middleware,
+      "ActionDispatch::MiddlewareStack::Middleware",
+      "actionpack/action_dispatch",
+      Middleware::Probe.new
+    )
+  end
+end