skylight 4.3.2 → 5.0.0.beta

data/lib/skylight/probes/active_job.rb

@@ -0,0 +1,29 @@
+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
+            begin
+              super
+            rescue Exception
+              trace.segment = "error" if trace
+              raise
+            end
+          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,37 @@
+module Skylight
+  module Probes
+    module ActiveJob
+      class EnqueueProbe
+        CAT = "other.active_job.enqueue".freeze
+
+        def install
+          ::ActiveJob::Base.around_enqueue do |job, block|
+            begin
+              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, &block)
+            end
+          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,54 @@
+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|
+            # rubocop:disable Lint/SuppressedException
+            begin
+              require "active_model/#{dir}/version"
+            rescue LoadError
+            end
+            # rubocop:enable 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,62 @@
+module Skylight
+  module Probes
+    module DelayedJob
+      module Instrumentation
+        include Skylight::Util::Logging
+
+        def run(job, *)
+          t { "Delayed::Job beginning trace" }
+
+          handler_name =
+            begin
+              if defined?(::Delayed::PerformableMethod) && job.payload_object.is_a?(::Delayed::PerformableMethod)
+                job.name
+              else
+                job.payload_object.class.name
+              end
+            rescue
+              UNKNOWN
+            end
+
+          Skylight.trace(handler_name, "app.delayed_job.worker", "Delayed::Worker#run",
+                         component: :worker, segment: job.queue) { super }
+        end
+
+        def handle_failed_job(*)
+          super
+          return unless Skylight.trace
+
+          Skylight.trace.segment = "error"
+        end
+      end
+
+      class Probe
+        UNKNOWN = "<Delayed::Job Unknown>".freeze
+
+        def install
+          return unless validate_version
+
+          ::Delayed::Worker.prepend(Instrumentation)
+        end
+
+        private
+
+          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 { puts "re-enabling: #{klass}" }
+            end
+          end
+        end
+      end
+    end
+
+    register(:elasticsearch, "Elasticsearch", "elasticsearch", Elasticsearch::Probe.new)
+  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/excon/middleware.rb

@@ -0,0 +1,66 @@
+require "skylight/formatters/http"
+
+module Skylight
+  module Probes
+    module Excon
+      # Middleware for Excon that instruments requests
+      class Middleware < ::Excon::Middleware::Base
+        def initialize(*)
+          @requests = {}
+          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 ? datum[:port] : nil
+            path   = datum[:path]
+            query  = datum[:query]
+
+            opts = Formatters::HTTP.build_opts(method, scheme, host, port, path, query)
+
+            @requests[datum.object_id] = 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.object_id))
+              meta = {}
+              if datum[:error].is_a?(Exception)
+                meta[:exception_object] = datum[:error]
+              end
+              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/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,43 @@
+# 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 do |klass_name|
+            safe_constantize(klass_name).prepend(Instrumentation)
+          end
+        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,125 @@
+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
+              nil
+            end
+        end
+      end
+
+      # for Rails <= 5.2 ActionDispatch::MiddlewareStack::Middleware
+      module Instrumentation
+        def build(*)
+          sk_instrument_middleware(super)
+        end
+
+        def 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