skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/probes/action_controller.rb

@@ -1,64 +0,0 @@
-module Skylight
-  module Probes
-    module ActionController
-      class Probe
-        def install
-          ::ActionController::Instrumentation.class_eval do
-            private
-            alias append_info_to_payload_without_sk append_info_to_payload
-            def append_info_to_payload(payload)
-              append_info_to_payload_without_sk(payload)
-              rendered_mime = begin
-                if respond_to?(:rendered_format)
-                  rendered_format
-                elsif content_type.is_a?(Mime::Type)
-                  content_type
-                elsif content_type.respond_to?(:to_s)
-                  type_str = content_type.to_s.split(';').first
-                  Mime::Type.lookup(type_str) unless type_str.blank?
-                end
-              end
-              payload[:rendered_format] = rendered_mime.try(:ref)
-              payload[:variant] = request.respond_to?(:variant) ? request.variant : nil
-            end
-          end
-
-          if Gem::Version.new(Rails.version) < Gem::Version.new('4.2.1')
-            # Backport https://github.com/rails/rails/pull/17978
-            ::ActionController::Instrumentation.class_eval do
-              def process_action(*args)
-                raw_payload = {
-                  :controller => self.class.name,
-                  :action     => self.action_name,
-                  :params     => request.filtered_parameters,
-                  :method     => request.request_method,
-                  :path       => (request.fullpath rescue "unknown")
-                }
-
-                if Gem::Version.new(Rails.version) < Gem::Version.new('3.1')
-                  raw_payload[:formats] = request.formats.map(&:to_sym)
-                else
-                  raw_payload[:format] = request.format.try(:ref)
-                end
-
-                ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
-
-                ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
-                  begin
-                    result = super
-                    payload[:status] = response.status
-                    result
-                  ensure
-                    append_info_to_payload(payload)
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    register(:action_controller, "ActionController::Instrumentation", "action_controller/metal/instrumentation", ActionController::Probe.new)
-  end
-end

data/lib/skylight/probes/action_dispatch.rb

@@ -1,30 +0,0 @@
-module Skylight
-  module Probes
-    module ActionDispatch
-      module Routing
-        module RouteSet
-          class Probe
-
-            def install
-              ::ActionDispatch::Routing::RouteSet.class_eval do
-                alias call_without_sk call
-                def call(env)
-                  trace = Skylight::Instrumenter.try(:instance).try(:current_trace)
-                  return call_without_sk(env) unless trace
-
-                  trace.endpoint = self.class.name
-                  Skylight.instrument(title: self.class.name, category: 'rack.app') do
-                    call_without_sk(env)
-                  end
-                end
-              end
-            end
-          end
-
-        end
-      end
-    end
-
-    register(:rails_router, 'ActionDispatch::Routing::RouteSet', 'action_dispatch/routing/route_set', ActionDispatch::Routing::RouteSet::Probe.new)
-  end
-end

data/lib/skylight/probes/action_view.rb

@@ -1,43 +0,0 @@
-module Skylight
-  module Probes
-    module ActionView
-      class Probe
-        def install
-          # Rails 3.0 didn't have ActionView::TemplateRenderer, but it also
-          # didn't have the bug that this probe is trying to fix. In Rails
-          # 3.1, a templating engine refactor moved the layout rendering out
-          # of the existing instrumentation, making any other events that
-          # happen inside of the layout appear to happen directly inside the
-          # parent (usually the controller).
-          return if [ActionPack::VERSION::MAJOR, ActionPack::VERSION::MINOR] == [3, 0]
-
-          ::ActionView::TemplateRenderer.class_eval do
-            alias render_with_layout_without_sk render_with_layout
-
-            def render_with_layout(path, locals, *args, &block) #:nodoc:
-              layout = nil
-
-              if path
-                if ::ActionView.respond_to?(:gem_version) && ::ActionView.gem_version >= Gem::Version.new('5.x')
-                  layout = find_layout(path, locals.keys, [formats.first])
-                else
-                  layout = find_layout(path, locals.keys)
-                end
-              end
-
-              if layout
-                instrument(:template, :identifier => layout.identifier) do
-                  render_with_layout_without_sk(path, locals, *args, &block)
-                end
-              else
-                render_with_layout_without_sk(path, locals, *args, &block)
-              end
-            end
-          end
-        end
-      end
-    end
-
-    register(:action_view, "ActionView::TemplateRenderer", "action_view", ActionView::Probe.new)
-  end
-end

data/lib/skylight/probes/active_model_serializers.rb

@@ -1,55 +0,0 @@
-module Skylight
-  module Probes
-    module ActiveModelSerializers
-      class Probe
-        def install
-          version = nil
-
-          # File moved location between version
-          %w(serializer serializers).each do |dir|
-            begin
-              require "active_model/#{dir}/version"
-            rescue LoadError
-            end
-          end
-
-          if defined?(::ActiveModel::Serializer::VERSION)
-            version = Gem::Version.new(::ActiveModel::Serializer::VERSION)
-          end
-
-          if !version || version < Gem::Version.new("0.5.0")
-            # Using $stderr here isn't great, but we don't have a logger accessible
-            $stderr.puts "[SKYLIGHT] [#{Skylight::VERSION}] Instrumention is only available for " \
-                          "ActiveModelSerializers version 0.5.0 and greater."
-            return
-          end
-
-          # We don't actually support the RCs correctly, requires
-          # a release after 0.10.0.rc3
-          if version >= Gem::Version.new("0.10.0.rc1")
-            # AS::N is built in to newer versions
-            return
-          end
-
-          # End users could override as_json without calling super, but it's likely safer
-          # than overriding serializable_array/hash/object.
-
-          [::ActiveModel::Serializer, ::ActiveModel::ArraySerializer].each do |klass|
-            klass.class_eval do
-              alias as_json_without_sk as_json
-              def as_json(*args)
-                payload = { serializer: self.class }
-                ActiveSupport::Notifications.instrument('render.active_model_serializers', payload) do
-                  as_json_without_sk(*args)
-                end
-              end
-            end
-          end
-
-        end
-      end
-    end
-
-    register(:active_model_serializers, "ActiveModel::Serializer", "active_model/serializer", ActiveModelSerializers::Probe.new)
-  end
-end

data/lib/skylight/probes/elasticsearch.rb

@@ -1,37 +0,0 @@
-module Skylight
-  module Probes
-    module Elasticsearch
-      class Probe
-        def install
-          ::Elasticsearch::Transport::Transport::Base.class_eval do
-            alias perform_request_without_sk perform_request
-            def perform_request(method, path, *args, &block)
-              ActiveSupport::Notifications.instrument "request.elasticsearch",
-                                                      name:   'Request',
-                                                      method: method,
-                                                      path:   path do
-
-
-                # Prevent HTTP-related probes from firing
-                Skylight::Normalizers::Faraday::Request.disable do
-                  disable_skylight_probe(:NetHTTP) do
-                    disable_skylight_probe(:HTTPClient) do
-                      perform_request_without_sk(method, path, *args, &block)
-                    end
-                  end
-                end
-              end
-            end
-
-            def disable_skylight_probe(class_name, &block)
-              klass = Skylight::Probes.const_get(class_name).const_get(:Probe) rescue nil
-              klass ? klass.disable(&block) : block.call
-            end
-          end
-        end
-      end
-    end
-
-    register(:elasticsearch, "Elasticsearch", "elasticsearch", Elasticsearch::Probe.new)
-  end
-end

data/lib/skylight/probes/excon.rb

@@ -1,26 +0,0 @@
-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, Skylight::Probes::Excon::Middleware)
-          else
-            # Using $stderr here isn't great, but we don't have a logger accessible
-            $stderr.puts "[SKYLIGHT] [#{Skylight::VERSION}] 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

@@ -1,68 +0,0 @@
-require 'skylight/formatters/http'
-
-module Skylight
-  module Probes
-    module Excon
-
-      # Middleware for Excon that instruments requests
-      class Middleware < ::Excon::Middleware::Base
-
-        # This probably won't work since config isn't defined
-        include Util::Logging
-
-        def initialize(*)
-          @requests = {}
-          super
-        end
-
-        # TODO:
-        # - 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 ? datum[:port] : nil
-            path   = datum[:path]
-            query  = datum[:query]
-
-            opts = Formatters::HTTP.build_opts(method, scheme, host, port, path, query)
-
-            @requests[datum.object_id] = Skylight.instrument(opts)
-          rescue Exception => e
-            error "failed to begin instrumentation for Excon; msg=%s", e.message
-          end
-
-          def end_instrumentation(datum)
-            if request = @requests.delete(datum.object_id)
-              Skylight.done(request)
-            end
-          rescue Exception => e
-            error "failed to end instrumentation for Excon; msg=%s", e.message
-          end
-
-      end
-    end
-  end
-end

data/lib/skylight/probes/faraday.rb

@@ -1,22 +0,0 @@
-module Skylight
-  module Probes
-    module Faraday
-      class Probe
-        def install
-          ::Faraday::Connection.class_eval do
-            alias initialize_without_sk initialize
-
-            def initialize(*args, &block)
-              initialize_without_sk(*args, &block)
-
-              @builder.insert 0, ::Faraday::Request::Instrumentation
-            end
-          end
-        end
-
-      end
-    end
-
-    register(:faraday, "Faraday", "faraday", Faraday::Probe.new)
-  end
-end

data/lib/skylight/probes/grape.rb

@@ -1,88 +0,0 @@
-module Skylight
-  module Probes
-    module Grape
-      class Probe
-        def install
-          version = Gem::Version.new(::Grape::VERSION)
-
-          if version >= Gem::Version.new("0.13.0")
-            # AS::N is built in to newer versions
-            return
-          end
-
-          Skylight::DEPRECATOR.deprecation_warning("Support for Grape versions before 0.13.0")
-
-          if version < Gem::Version.new("0.10.0")
-            # Using $stderr here isn't great, but we don't have a logger accessible
-            $stderr.puts "[SKYLIGHT] [#{Skylight::VERSION}] The Grape probe only works with version 0.10.0+ " \
-                          "and will be disabled."
-
-            return
-          end
-
-          # Grape relies on this but does doesn't correctly require it.
-          # However, when using ActiveSupport 4 it is implicitly loaded,
-          #   in AS 3, it will fail.
-          # https://github.com/ruby-grape/grape/issues/1087
-          require 'active_support/core_ext/hash/except'
-
-          ::Grape::Endpoint.class_eval do
-            alias initialize_without_sk initialize
-            def initialize(*args, &block)
-              initialize_without_sk(*args, &block)
-
-              # This solution of wrapping the block is effective, but potentially fragile.
-              # A cleaner solution would be to call the original initialize with the already
-              # modified block. However, Grape does some odd stuff with the block binding
-              # that makes this difficult to reason about.
-              if original_block = @block
-                @block = lambda do |endpoint_instance|
-                  ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: endpoint_instance) do
-                    original_block.call(endpoint_instance)
-                  end
-                end
-              end
-            end
-
-            alias run_without_sk run
-            def run(*args)
-              ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self) do
-                run_without_sk(*args)
-              end
-            end
-
-            alias run_filters_without_sk run_filters
-            def run_filters(filters)
-              # Unfortunately, the type isn't provided to the method so we have
-              # to try to guess it by looking at the contents. This is only reliable
-              # if the filters aren't empty.
-              if filters && !filters.empty?
-                type = case filters
-                  when befores            then :before
-                  when before_validations then :before_validation
-                  when after_validations  then :after_validation
-                  when afters             then :after
-                  else                         :other
-                  end
-              else
-                type = :unknown
-              end
-
-              payload = {
-                endpoint: self,
-                filters: filters,
-                type: type
-              }
-
-              ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', payload) do
-                run_filters_without_sk(filters)
-              end
-            end
-          end
-        end
-      end
-    end
-
-    register(:grape, "Grape::Endpoint", "grape/endpoint", Grape::Probe.new)
-  end
-end

data/lib/skylight/probes/httpclient.rb

@@ -1,46 +0,0 @@
-require 'skylight/formatters/http'
-
-module Skylight
-  module Probes
-    module HTTPClient
-      class Probe
-        DISABLED_KEY = :__skylight_httpclient_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
-          ::HTTPClient.class_eval do
-            # HTTPClient has request methods on the class object itself,
-            # but the internally instantiate a client and perform the method
-            # on that, so this instance method override will cover both
-            # `HTTPClient.get(...)` and `HTTPClient.new.get(...)`
-
-            alias do_request_without_sk do_request
-            def do_request(method, uri, query, body, header, &block)
-              if Skylight::Probes::HTTPClient::Probe.disabled?
-                return do_request_without_sk(method, uri, query, body, header, &block)
-              end
-
-              opts = Formatters::HTTP.build_opts(method, uri.scheme, uri.host, uri.port, uri.path, uri.query)
-
-              Skylight.instrument(opts) do
-                do_request_without_sk(method, uri, query, body, header, &block)
-              end
-            end
-          end
-        end
-      end # class Probe
-    end # module Probes::HTTPClient
-
-    register(:httpclient, "HTTPClient", "httpclient", HTTPClient::Probe.new)
-  end
-end