skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/probes/middleware.rb

@@ -1,68 +0,0 @@
-module Skylight
-  module Probes
-    module Middleware
-
-      def self.add_instrumentation(middleware, default_name="Anonymous Middleware", category="rack.middleware")
-        middleware.instance_eval <<-RUBY, __FILE__, __LINE__ + 1
-          alias call_without_sk call
-          def call(*args, &block)
-            trace = Skylight::Instrumenter.try(:instance).try(:current_trace)
-            return call_without_sk(*args, &block) unless trace
-
-            begin
-              name = self.class.name || "#{default_name}"
-
-              trace.endpoint = name
-
-              span = Skylight.instrument(title: name, category: "#{category}")
-              resp = call_without_sk(*args, &block)
-
-              proxied_response = Skylight::Middleware.with_after_close(resp) do
-                trace.done(span)
-              end
-            rescue Exception => err
-              # FIXME: Log this?
-              trace.done(span, exception_object: err)
-              raise
-            ensure
-              unless err || 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 Core::Trace#deferred_spans or Core::Trace#stop for more information.
-                trace.done(span, defer: true)
-              end
-            end
-          end
-        RUBY
-      end
-
-      class Probe
-        def install
-          ::ActionDispatch::MiddlewareStack::Middleware.class_eval do
-            alias build_without_sk build
-            def build(*args)
-              sk_instrument_middleware(build_without_sk(*args))
-            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?(:call_without_sk)
-
-              # On Rails 3, ActionDispatch::Session::CookieStore is frozen, for one
-              return middleware if middleware.frozen?
-
-              Skylight::Probes::Middleware.add_instrumentation(middleware)
-
-              middleware
-            end
-          end
-        end
-      end
-    end
-
-    register(:middleware, "ActionDispatch::MiddlewareStack::Middleware", "actionpack/action_dispatch", Middleware::Probe.new)
-  end
-end

data/lib/skylight/probes/mongo.rb

@@ -1,161 +0,0 @@
-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 = [:insert, :find, :count, :distinct, :update, :findandmodify, :delete].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
-          instrumenter = Skylight::Instrumenter.instance
-          instrumenter ? instrumenter.config : nil
-        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
-
-            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 event.command_name == :findandmodify
-              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
-
-
-            # 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
-            }
-
-            @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)
-              Skylight.done(original_event)
-            end
-          rescue Exception => e
-            error "failed to end instrumentation for Mongo; msg=%s", e.message
-          end
-
-          def add_value(key, command, payload)
-            if command.has_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|
-              if v.is_a?(Hash)
-                ret[k] = extract_binds(v)
-              else
-                ret[k] = '?'.freeze
-              end
-            end
-
-            ret
-          end
-
-      end
-    end
-
-    register(:mongo, "Mongo", "mongo", Mongo::Probe.new)
-  end
-end

data/lib/skylight/probes/mongoid.rb

@@ -1,21 +0,0 @@
-module Skylight
-  module Probes
-    module Mongoid
-      class Probe
-
-        def install
-          require 'mongoid/version'
-          version = Gem::Version.new(::Mongoid::VERSION)
-
-          if version < Gem::Version.new("5.0")
-            Skylight.probe(:moped)
-          else
-            Skylight.probe(:mongo)
-          end
-        end
-      end
-    end
-
-    register(:mongoid, "Mongoid", "mongoid", Mongoid::Probe.new)
-  end
-end

data/lib/skylight/probes/moped.rb

@@ -1,39 +0,0 @@
-module Skylight
-  module Probes
-    module Moped
-      class Probe
-
-        def install
-          unless defined?(::Moped::Instrumentable)
-            # Using $stderr here isn't great, but we don't have a logger accessible
-            $stderr.puts "[SKYLIGHT] [#{Skylight::VERSION}] The installed version of Moped doesn't " \
-                          "support instrumentation. The Moped probe will be disabled."
-
-            return
-          end
-
-          ::Moped::Instrumentable.module_eval do
-            alias instrument_without_sk instrument
-
-            def instrument(*args, &block)
-              # Mongoid sets the instrumenter to AS::N
-              if instrumenter == ActiveSupport::Notifications
-                asn_block = block
-              else
-                # If the instrumenter hasn't been changed to AS::N use both
-                asn_block = Proc.new do
-                  ActiveSupport::Notifications.instrument(*args, &block)
-                end
-              end
-
-              instrument_without_sk(*args, &asn_block)
-            end
-          end
-        end
-
-      end
-    end
-
-    register(:moped, "Moped", "moped", Moped::Probe.new)
-  end
-end

data/lib/skylight/probes/net_http.rb

@@ -1,58 +0,0 @@
-require 'skylight/formatters/http'
-
-module Skylight
-  module Probes
-    module NetHTTP
-      # 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
-          Thread.current[DISABLED_KEY] = true
-          yield
-        ensure
-          Thread.current[DISABLED_KEY] = false
-        end
-
-        def self.disabled?
-          !!Thread.current[DISABLED_KEY]
-        end
-
-        def install
-          Net::HTTP.class_eval do
-            alias request_without_sk request
-
-            def request(req, body = nil, &block)
-              if !started? || Skylight::Probes::NetHTTP::Probe.disabled?
-                return request_without_sk(req, body, &block)
-              end
-
-              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 ||= self.address
-              port ||= self.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) do
-                request_without_sk(req, body, &block)
-              end
-            end
-          end
-        end
-      end
-    end
-
-    register(:net_http, "Net::HTTP", "net/http", NetHTTP::Probe.new)
-  end
-end

data/lib/skylight/probes/redis.rb

@@ -1,71 +0,0 @@
-module Skylight
-  module Probes
-    module Redis
-      class Probe
-        def install
-          version = defined?(::Redis::VERSION) ? Gem::Version.new(::Redis::VERSION) : nil
-
-          if !version || version < Gem::Version.new("3.0.0")
-            # Using $stderr here isn't great, but we don't have a logger accessible
-            $stderr.puts "[SKYLIGHT] [#{Skylight::VERSION}] The installed version of Redis doesn't " \
-                          "support Middlewares. At least version 3.0.0 is required."
-            return
-          end
-
-          ::Redis::Client.class_eval do
-            alias call_without_sk call
-
-            def call(command, &block)
-              command_name = command[0]
-
-              return call_without_sk(command, &block) if command_name == :auth
-
-              opts = {
-                category: "db.redis.command",
-                title:    command_name.upcase.to_s
-              }
-
-              Skylight.instrument(opts) do
-                call_without_sk(command, &block)
-              end
-            end
-          end
-        end
-
-        # 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
-
-        ::Redis.class_eval do
-          alias pipelined_without_sk pipelined
-
-          def pipelined(&block)
-            Skylight.instrument(PIPELINED_OPTS) do
-              pipelined_without_sk(&block)
-            end
-          end
-
-
-          alias multi_without_sk multi
-
-          def multi(&block)
-            Skylight.instrument(MULTI_OPTS) do
-              multi_without_sk(&block)
-            end
-          end
-        end
-      end
-    end
-
-    register(:redis, "Redis", "redis", Redis::Probe.new)
-  end
-end

data/lib/skylight/probes/sequel.rb

@@ -1,37 +0,0 @@
-# Supports 3.12.0+
-module Skylight
-  module Probes
-    module Sequel
-      class Probe
-        def install
-          if Gem::Version.new(::Sequel.version) < Gem::Version.new('4.0')
-            Skylight::DEPRECATOR.deprecation_warning("Support for Sequel versions before 4.0")
-          end
-
-          require 'sequel/database/logging'
-
-          method_name = ::Sequel::Database.method_defined?(:log_connection_yield) ? 'log_connection_yield' : 'log_yield'
-
-          ::Sequel::Database.class_eval <<-end_eval
-            alias #{method_name}_without_sk #{method_name}
-
-            def #{method_name}(sql, *args, &block)
-              #{method_name}_without_sk(sql, *args) do
-                ::ActiveSupport::Notifications.instrument(
-                  "sql.sequel",
-                  sql: sql,
-                  name: "SQL",
-                  binds: args
-                ) do
-                  block.call
-                end
-              end
-            end
-          end_eval
-        end
-      end
-    end
-
-    register(:sequel, "Sequel", "sequel", Sequel::Probe.new)
-  end
-end