skylight 4.2.3 → 5.0.0.beta3

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 = {}.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 = {}
+              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,126 @@
+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

data/lib/skylight/probes/mongo.rb

@@ -0,0 +1,164 @@
+module Skylight
+  module Probes
+    module Mongo
+      CAT = "db.mongo.command".freeze
+
+      class Probe
+        def install
+          ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, Subscriber.new)
+        end
+      end
+
+      class Subscriber
+        include Skylight::Util::Logging
+
+        COMMANDS = %i[insert find count distinct update findandmodify findAndModify delete aggregate].freeze
+
+        COMMAND_NAMES = {
+          findandmodify: "findAndModify".freeze
+        }.freeze
+
+        def initialize
+          @events = {}
+        end
+
+        def started(event)
+          begin_instrumentation(event)
+        end
+
+        def succeeded(event)
+          end_instrumentation(event)
+        end
+
+        def failed(event)
+          end_instrumentation(event)
+        end
+
+        # For logging
+        def config
+          Skylight.config
+        end
+
+        private
+
+          def begin_instrumentation(event)
+            return unless COMMANDS.include?(event.command_name.to_sym)
+
+            command_name = COMMAND_NAMES[event.command_name] || event.command_name.to_s
+
+            title = "#{event.database_name}.#{command_name}"
+
+            command = event.command
+
+            # Not sure if this will always exist
+            # Delete so the description will be less redundant
+            if (target = command[event.command_name])
+              title << " #{target}"
+            end
+
+            payload = {}
+
+            # Ruby Hashes are ordered based on insertion so do the most important ones first
+
+            add_value("key".freeze, command, payload)
+            add_bound("query".freeze, command, payload)
+            add_bound("filter".freeze, command, payload)
+            add_value("sort".freeze, command, payload)
+
+            if command_name == "findAndModify".freeze
+              add_bound("update".freeze, command, payload)
+            end
+
+            add_value("remove".freeze, command, payload)
+            add_value("new".freeze, command, payload)
+
+            if (updates = command["updates".freeze])
+              # AFAICT the gem generally just sends one item in the updates array
+              update = updates[0]
+              update_payload = {}
+              add_bound("q".freeze, update, update_payload)
+              add_bound("u".freeze, update, update_payload)
+              add_value("multi".freeze, update, update_payload)
+              add_value("upsert".freeze, update, update_payload)
+
+              payload["updates".freeze] = [update_payload]
+
+              if updates.length > 1
+                payload["updates".freeze] << "..."
+              end
+            end
+
+            if (deletes = command["deletes".freeze])
+              # AFAICT the gem generally just sends one item in the updates array
+              delete = deletes[0]
+              delete_payload = {}
+              add_bound("q".freeze, delete, delete_payload)
+              add_value("limit".freeze, delete, delete_payload)
+
+              payload["deletes".freeze] = [delete_payload]
+
+              if deletes.length > 1
+                payload["deletes".freeze] << "..."
+              end
+            end
+
+            if (pipeline = command["pipeline".freeze])
+              payload["pipeline".freeze] = pipeline.map { |segment| extract_binds(segment) }
+            end
+
+            # We're ignoring documents from insert because they could have completely inconsistent
+            # format which would make it hard to merge.
+
+            opts = {
+              category:    CAT,
+              title:       title,
+              description: payload.empty? ? nil : payload.to_json,
+              meta:        { database: event.database_name },
+              internal:    true
+            }
+
+            @events[event.operation_id] = Skylight.instrument(opts)
+          rescue Exception => e
+            error "failed to begin instrumentation for Mongo; msg=%s", e.message
+          end
+
+          def end_instrumentation(event)
+            if (original_event = @events.delete(event.operation_id))
+              meta = {}
+              if event.is_a?(::Mongo::Monitoring::Event::CommandFailed)
+                meta[:exception] = ["CommandFailed", event.message]
+              end
+              Skylight.done(original_event, meta)
+            end
+          rescue Exception => e
+            error "failed to end instrumentation for Mongo; msg=%s", e.message
+          end
+
+          def add_value(key, command, payload)
+            if command.key?(key)
+              value = command[key]
+              payload[key] = value
+            end
+          end
+
+          def add_bound(key, command, payload)
+            if (value = command[key])
+              payload[key] = extract_binds(value)
+            end
+          end
+
+          def extract_binds(hash)
+            ret = {}
+
+            hash.each do |k, v|
+              ret[k] = v.is_a?(Hash) ? extract_binds(v) : "?".freeze
+            end
+
+            ret
+          end
+      end
+    end
+
+    register(:mongo, "Mongo", "mongo", Mongo::Probe.new)
+  end
+end