skylight 4.3.2 → 5.0.0.beta

data/lib/skylight/probes/mongo.rb

@@ -0,0 +1,163 @@
+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 }
+            }
+
+            @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

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,55 @@
+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
+          port ||= port
+
+          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/redis.rb

@@ -0,0 +1,60 @@
+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
+      }.freeze
+
+      MULTI_OPTS = {
+        category: "db.redis.multi".freeze,
+        title:    "MULTI".freeze
+      }.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
+          }
+
+          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,33 @@
+# 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,63 @@
+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, *)
+          # Pass along a useful "virtual path" to Tilt. The Tilt probe will handle
+          # instrumenting correctly.
+          options[:sky_virtual_path] = data.is_a?(Symbol) ? data.to_s : "Inline template (#{engine})"
+
+          super
+        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 build(*)
+          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,27 @@
+# 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:    options[:sky_virtual_path] || basename || "Unknown template name"
+          }
+
+          Skylight.instrument(opts) do
+            super(*args, &block)
+          end
+        end
+      end
+
+      class Probe
+        def install
+          ::Tilt::Template.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:tilt, "Tilt::Template", "tilt/template", Tilt::Probe.new)
+  end
+end