skylight 4.2.3 → 5.3.0

data/lib/skylight/probes/mongo.rb

@@ -0,0 +1,156 @@
+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)
+
+          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,13 @@
+module Skylight
+  module Probes
+    module Mongoid
+      class Probe
+        def install
+          Skylight::Probes.probe(:mongo)
+        end
+      end
+    end
+
+    register(:mongoid, "Mongoid", "mongoid", Mongoid::Probe.new)
+  end
+end

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,51 @@
+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 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
+
+          ::Redis::Client.prepend(ClientInstrumentation)
+          ::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_method :build_without_sk, :build
+      module Instrumentation
+        def setup_default_middleware(builder)
+          builder.use Skylight::Middleware
+          super
+        end
+      end
 
-            def build(*args, &block)
-              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

data/lib/skylight/probes.rb

@@ -0,0 +1,173 @@
+require "pathname"
+require "active_support/inflector"
+
+module Skylight
+  # @api private
+  module Probes
+    class ProbeRegistration
+      attr_reader :name, :const_name, :require_paths, :probe
+
+      def initialize(name, const_name, require_paths, probe)
+        @name = name
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @probe = probe
+      end
+
+      def install
+        probe.install
+      rescue StandardError, LoadError => e
+        log_install_exception(e)
+      end
+
+      def constant_available?
+        Skylight::Probes.constant_available?(const_name)
+      end
+
+      private
+
+      def log_install_exception(err)
+        description = err.class.to_s
+        description << ": #{err.message}" unless err.message.empty?
+
+        backtrace = err.backtrace.map { |l| "  #{l}" }.join("\n")
+
+        # rubocop:disable Lint/SuppressedException
+        gems =
+          begin
+            Bundler.locked_gems.dependencies.map { |d| [d.name, d.requirement.to_s] }
+          rescue StandardError
+          end
+
+        # rubocop:enable Lint/SuppressedException
+
+        error =
+          "[SKYLIGHT] [#{Skylight::VERSION}] Encountered an error while installing the " \
+            "probe for #{const_name}. Please notify support@skylight.io with the debugging " \
+            "information below. It's recommended that you disable this probe until the " \
+            "issue is resolved." \
+            "\n\nERROR: #{description}\n\n#{backtrace}\n\n"
+
+        if gems
+          gems_string = gems.map { |g| "  #{g[0]}   #{g[1]}" }.join("\n")
+          error << "GEMS:\n\n#{gems_string}\n\n"
+        end
+
+        $stderr.puts(error)
+      end
+    end
+
+    class << self
+      def constant_available?(const_name)
+        ::ActiveSupport::Inflector.safe_constantize(const_name).present?
+      end
+
+      def install!
+        pending = registered.values - installed.values
+
+        pending.each do |registration|
+          registration.constant_available? ? install_probe(registration) : register_require_hook(registration)
+        end
+      end
+
+      def install_probe(registration)
+        return if installed.key?(registration.name)
+
+        installed[registration.name] = registration
+        registration.install
+      end
+
+      def add_path(path)
+        root = Pathname.new(path)
+        Pathname
+          .glob(root.join("./**/*.rb"))
+          .each do |f|
+            name = f.relative_path_from(root).sub_ext("").to_s
+            raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{f}" if available.key?(name)
+
+            available[name] = f
+          end
+      end
+
+      def available
+        @available ||= {}
+      end
+
+      def probe(*probes)
+        unknown = probes.map(&:to_s) - available.keys
+        raise ArgumentError, "unknown probes: #{unknown.join(", ")}" unless unknown.empty?
+
+        probes.each { |p| require available[p.to_s] }
+      end
+
+      def registered
+        @registered ||= {}
+      end
+
+      def require_hooks
+        @require_hooks ||= {}
+      end
+
+      def installed
+        @installed ||= {}
+      end
+
+      def register(name, *args)
+        raise "already registered: #{name}" if registered.key?(name)
+
+        registered[name] = ProbeRegistration.new(name, *args)
+
+        true
+      end
+
+      def require_hook(require_path)
+        each_by_require_path(require_path) do |registration|
+          # Double check constant is available
+          next unless registration.constant_available?
+
+          install_probe(registration)
+
+          # Don't need this to be called again
+          unregister_require_hook(registration)
+        end
+      end
+
+      def register_require_hook(registration)
+        registration.require_paths.each do |p|
+          require_hooks[p] ||= []
+          require_hooks[p] << registration
+        end
+      end
+
+      def unregister_require_hook(registration)
+        registration.require_paths.each do |p|
+          require_hooks[p].delete(registration)
+          require_hooks.delete(p) if require_hooks[p].empty?
+        end
+      end
+
+      def each_by_require_path(require_path)
+        return unless require_hooks.key?(require_path)
+
+        # dup because we may be mutating the array
+        require_hooks[require_path].dup.each { |registration| yield registration }
+      end
+    end
+
+    add_path(File.expand_path("./probes", __dir__))
+  end
+end
+
+# @api private
+module Kernel
+  # Unfortunately, we can't use prepend here, in part because RubyGems changes require with an alias
+  alias require_without_sk require
+
+  def require(name)
+    require_without_sk(name).tap do
+      Skylight::Probes.require_hook(name)
+    rescue Exception => e
+      warn("[SKYLIGHT] Rescued exception in require hook", e)
+    end
+  end
+end