skylight 3.1.4 → 5.3.4

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

data/lib/skylight/probes/mongo.rb

@@ -0,0 +1,169 @@
+module Skylight
+  module Probes
+    module Mongo
+      CAT = "db.mongo.command".freeze
+
+      class Probe
+        def install
+          subscriber = Subscriber.new
+
+          # From the mongo driver:
+          #
+          # > Global subscriptions must be established prior to creating
+          # > clients. When a client is constructed it copies subscribers from
+          # > the Global module; subsequent subscriptions or unsubscriptions
+          # > on the Global module have no effect on already created clients.
+          #
+          # So, for existing clients created before the Skylight initializer
+          # runs, we'll have to subscribe to those individually.
+          ::Mongoid::Clients.clients.each { |_name, client| client.subscribe(::Mongo::Monitoring::COMMAND, subscriber) }
+
+          ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, subscriber)
+        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)
+
+          add_bound("update".freeze, command, payload) if command_name == "findAndModify".freeze
+
+          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]
+
+            payload["updates".freeze] << "..." if updates.length > 1
+          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]
+
+            payload["deletes".freeze] << "..." if deletes.length > 1
+          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 { |k, v| ret[k] = v.is_a?(Hash) ? extract_binds(v) : "?".freeze }
+
+          ret
+        end
+      end
+    end
+
+    register(:mongo, "Mongo", "mongo", Mongo::Probe.new)
+  end
+end

data/lib/skylight/probes/mongoid.rb

@@ -0,0 +1,6 @@
+# Older versions of the mongoid uses the moped under-the-hood, while newer
+# verions uses the official driver. It used to be that the the mongoid probe
+# exists to detect and enable either one of those underlying probes, but at
+# this point we no longer support moped, so this is now just an alias for the
+# mongo probe.
+require_relative "mongo"

data/lib/skylight/probes/net_http.rb

@@ -0,0 +1,54 @@
+require "skylight/formatters/http"
+
+module Skylight
+  module Probes
+    module NetHTTP
+      module Instrumentation
+        def request(req, *)
+          return super if !started? || Probes::NetHTTP::Probe.disabled?
+
+          method = req.method
+
+          # req['host'] also includes special handling for default ports
+          host, port = req["host"] ? req["host"].split(":") : nil
+
+          # If we're connected with a persistent socket
+          host ||= address
+
+          path = req.path
+          scheme = use_ssl? ? "https" : "http"
+
+          # Contained in the path
+          query = nil
+
+          opts = Formatters::HTTP.build_opts(method, scheme, host, port, path, query)
+
+          Skylight.instrument(opts) { super }
+        end
+      end
+
+      # Probe for instrumenting Net::HTTP requests. Works by monkeypatching the default Net::HTTP#request method.
+      class Probe
+        DISABLED_KEY = :__skylight_net_http_disabled
+
+        def self.disable
+          state_was = Thread.current[DISABLED_KEY]
+          Thread.current[DISABLED_KEY] = true
+          yield
+        ensure
+          Thread.current[DISABLED_KEY] = state_was
+        end
+
+        def self.disabled?
+          !!Thread.current[DISABLED_KEY]
+        end
+
+        def install
+          Net::HTTP.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:net_http, "Net::HTTP", "net/http", NetHTTP::Probe.new)
+  end
+end

data/lib/skylight/probes/rack_builder.rb

@@ -0,0 +1,37 @@
+module Skylight
+  module Probes
+    module Rack
+      module Builder
+        module Instrumentation
+          def use(middleware, *args, &block)
+            if @map
+              mapping = @map
+              @map = nil
+              @use << proc { |app| generate_map(app, mapping) }
+            end
+            @use << proc do |app|
+              middleware
+                .new(app, *args, &block)
+                .tap do |middleware_instance|
+                  Skylight::Probes::Middleware::Instrumentation.sk_instrument_middleware(middleware_instance)
+                end
+            end
+          end
+          ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+        end
+
+        class Probe
+          def install
+            if defined?(::Rack.release) && Gem::Version.new(::Rack.release) >= ::Gem::Version.new("1.4") &&
+                 defined?(::Rack::Builder)
+              require "skylight/probes/middleware"
+              ::Rack::Builder.prepend(Instrumentation)
+            end
+          end
+        end
+      end
+    end
+
+    register(:rack_builder, "Rack::Builder", "rack/builder", Skylight::Probes::Rack::Builder::Probe.new)
+  end
+end

data/lib/skylight/probes/redis.rb

@@ -0,0 +1,68 @@
+module Skylight
+  module Probes
+    module Redis
+      # Unfortunately, because of the nature of pipelining, there's no way for us to
+      # give a time breakdown on the individual items.
+
+      PIPELINED_OPTS = { category: "db.redis.pipelined".freeze, title: "PIPELINE".freeze, internal: true }.freeze
+
+      MULTI_OPTS = { category: "db.redis.multi".freeze, title: "MULTI".freeze, internal: true }.freeze
+
+      module ClientInstrumentation
+        def call(command, *)
+          command_name = command[0]
+
+          return super if command_name == :auth
+
+          opts = { category: "db.redis.command", title: command_name.upcase.to_s, internal: true }
+
+          Skylight.instrument(opts) { super }
+        end
+      end
+
+      module ClientInstrumentationV5
+        def call_v(command)
+          command_name = command[0]
+
+          return super if command_name == :auth
+
+          opts = { category: "db.redis.command", title: command_name.upcase.to_s, internal: true }
+
+          Skylight.instrument(opts) { super }
+        end
+      end
+
+      module Instrumentation
+        def pipelined(*)
+          Skylight.instrument(PIPELINED_OPTS) { super }
+        end
+
+        def multi(*)
+          Skylight.instrument(MULTI_OPTS) { super }
+        end
+      end
+
+      class Probe
+        def install
+          version = defined?(::Redis::VERSION) ? Gem::Version.new(::Redis::VERSION) : nil
+
+          if !version || version < Gem::Version.new("3.0.0")
+            Skylight.error "The installed version of Redis doesn't support Middlewares. " \
+                             "At least version 3.0.0 is required."
+            return
+          end
+
+          if ::Redis::Client.method_defined?(:call_v)
+            ::Redis::Client.prepend(ClientInstrumentationV5)
+          else
+            ::Redis::Client.prepend(ClientInstrumentation)
+          end
+
+          ::Redis.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:redis, "Redis", "redis", Redis::Probe.new)
+  end
+end

data/lib/skylight/probes/sequel.rb

@@ -0,0 +1,29 @@
+# Supports 3.12.0+
+module Skylight
+  module Probes
+    module Sequel
+      class Probe
+        def install
+          require "sequel/database/logging"
+
+          method_name = ::Sequel::Database.method_defined?(:log_connection_yield) ? "log_connection_yield" : "log_yield"
+
+          mod =
+            Module.new do
+              define_method method_name do |sql, *args, &block|
+                super(sql, *args) do
+                  ::ActiveSupport::Notifications.instrument("sql.sequel", sql: sql, name: "SQL", binds: args) do
+                    block.call
+                  end
+                end
+              end
+            end
+
+          ::Sequel::Database.prepend(mod)
+        end
+      end
+    end
+
+    register(:sequel, "Sequel", "sequel", Sequel::Probe.new)
+  end
+end

data/lib/skylight/probes/sinatra.rb

@@ -0,0 +1,66 @@
+module Skylight
+  module Probes
+    module Sinatra
+      module ClassInstrumentation
+        def compile!(verb, path, *)
+          super.tap do |_, _, keys_or_wrapper, wrapper|
+            wrapper ||= keys_or_wrapper
+
+            # Deal with the situation where the path is a regex, and the default behavior
+            # of Ruby stringification produces an unreadable mess
+            if path.is_a?(Regexp)
+              human_readable = "<sk-regex>%r{#{path.source}}</sk-regex>"
+              wrapper.instance_variable_set(:@route_name, "#{verb} #{human_readable}")
+            else
+              wrapper.instance_variable_set(:@route_name, "#{verb} #{path}")
+            end
+          end
+        end
+      end
+
+      module Instrumentation
+        def dispatch!(*)
+          super.tap do
+            if (trace = Skylight.instrumenter&.current_trace) && (route = env["sinatra.route"])
+              # Include the app's mount point (if available)
+              script_name = trace.instrumenter.config.sinatra_route_prefixes? && env["SCRIPT_NAME"]
+
+              trace.endpoint =
+                if script_name && !script_name.empty?
+                  verb, path = route.split(" ", 2)
+                  "#{verb} [#{script_name}]#{path}"
+                else
+                  route
+                end
+            end
+          end
+        end
+
+        def compile_template(engine, data, options, *)
+          super.tap do |template|
+            if defined?(::Tilt::Template) && template.is_a?(::Tilt::Template)
+              # Pass along a useful "virtual path" to Tilt. The Tilt probe will handle
+              # instrumenting correctly.
+              virtual_path = data.is_a?(Symbol) ? data.to_s : "Inline template (#{engine})"
+              template.instance_variable_set(:@__sky_virtual_path, virtual_path)
+            end
+          end
+        end
+      end
+
+      class Probe
+        def install
+          if ::Sinatra::VERSION < "1.4.0"
+            Skylight.error "Sinatra must be version 1.4.0 or greater."
+            return
+          end
+
+          ::Sinatra::Base.singleton_class.prepend(ClassInstrumentation)
+          ::Sinatra::Base.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:sinatra, "Sinatra::Base", "sinatra/base", Sinatra::Probe.new)
+  end
+end

data/lib/skylight/probes/sinatra_add_middleware.rb

@@ -1,20 +1,20 @@
 module Skylight
   module Probes
     module Sinatra
-      class Probe
-        def install
-          class << ::Sinatra::Base
-            alias build_without_sk build
+      module Instrumentation
+        def setup_default_middleware(builder)
+          builder.use Skylight::Middleware
+          super
+        end
+      end
 
-            def build(*args, &block)
-              self.use Skylight::Middleware
-              build_without_sk(*args, &block)
-            end
-          end
+      class AddMiddlewareProbe
+        def install
+          ::Sinatra::Base.singleton_class.prepend(Instrumentation)
         end
       end
     end
 
-    Skylight::Core::Probes.register(:sinatra_add_middleware, "Sinatra::Base", "sinatra/base", Sinatra::Probe.new)
+    register(:sinatra_add_middleware, "Sinatra::Base", "sinatra/base", Sinatra::AddMiddlewareProbe.new)
   end
 end

data/lib/skylight/probes/tilt.rb

@@ -0,0 +1,25 @@
+# Should support 0.2+, though not tested against older versions
+module Skylight
+  module Probes
+    module Tilt
+      module Instrumentation
+        def render(*args, &block)
+          opts = {
+            category: "view.render.template",
+            title: @__sky_virtual_path || options[:sky_virtual_path] || basename || "Unknown template name"
+          }
+
+          Skylight.instrument(opts) { super(*args, &block) }
+        end
+      end
+
+      class Probe
+        def install
+          ::Tilt::Template.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:tilt, "Tilt::Template", "tilt/template", Tilt::Probe.new)
+  end
+end