skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/normalizers/couch_potato/query.rb

@@ -1,20 +0,0 @@
-require "json"
-
-module Skylight
-  module Normalizers
-    module CouchPotato
-      class Query < Normalizer
-        register "couch_potato.load"
-        register "couch_potato.view"
-
-        CAT = "db.couch_db.query".freeze
-
-        def normalize(trace, name, payload)
-          description = payload[:name] if payload
-          _name = name.sub('couch_potato.', '')
-          [CAT, _name, description]
-        end
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/default.rb

@@ -1,27 +0,0 @@
-module Skylight
-  module Normalizers
-
-    # The default normalizer, used if no other is found.
-    class Default
-
-      # @param trace [Skylight::Messages::Trace::Builder] ignored, only present to match API
-      # @param name [String]
-      # @param payload [Hash]
-      # @option payload [String] :title
-      # @option payload [String] :description
-      # @return [Array, :skip] the normalized array or `:skip` if `name` is not part of a known {Skylight::TIERS tier}
-      def normalize(trace, name, payload)
-        if name =~ TIER_REGEX
-          [
-            name,
-            payload[:title],
-            payload[:description]
-          ]
-        else
-          :skip
-        end
-      end
-
-    end
-  end
-end

data/lib/skylight/normalizers/elasticsearch/request.rb

@@ -1,20 +0,0 @@
-module Skylight
-  module Normalizers
-    module Elasticsearch
-      class Request < Normalizer
-        register "request.elasticsearch"
-
-        CAT = "db.elasticsearch.request".freeze
-
-        def normalize(trace, name, payload)
-          path = payload[:path].split('/')
-          title = [payload[:method], path[0]].compact.join(' ')
-          desc = {}
-          desc[:type] = path[1] if path[1]
-          desc[:id] = '?' if path[2]
-          [ CAT, title, desc.presence.try(:to_json) ]
-        end
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/faraday/request.rb

@@ -1,38 +0,0 @@
-module Skylight
-  module Normalizers
-    module Faraday
-      class Request < Normalizer
-        register "request.faraday"
-
-        DISABLED_KEY = :__skylight_faraday_disabled
-
-        def self.disable
-          Thread.current[DISABLED_KEY] = true
-          yield
-        ensure
-          Thread.current[DISABLED_KEY] = false
-        end
-
-        def disabled?
-          !!Thread.current[DISABLED_KEY]
-        end
-
-        def normalize(_trace, _name, payload)
-          uri = payload[:url]
-
-          if disabled?
-            return :skip
-          end
-
-          opts = Formatters::HTTP.build_opts(payload[:method], uri.scheme,
-          uri.host, uri.port, uri.path, uri.query)
-          description = opts[:title]
-
-          # We use "Faraday" as the title to differentiate it in the UI in 
-          # case it's wrapping or is wrapped by another HTTP backend
-          [opts[:category], "Faraday", description]
-        end
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/grape/endpoint.rb

@@ -1,30 +0,0 @@
-module Skylight
-  module Normalizers
-    module Grape
-      class Endpoint < Normalizer
-        %w(run
-            render
-            run_filters).each do |type|
-          require "skylight/normalizers/grape/endpoint_#{type}"
-        end
-
-        private
-
-          def get_method(endpoint)
-            method = endpoint.options[:method].first
-            method = "#{method}..." if endpoint.options[:method].length > 1
-            method
-          end
-
-          def get_path(endpoint)
-            endpoint.options[:path].join("/")
-          end
-
-          def get_namespace(endpoint)
-            ::Grape::Namespace.joined_space(endpoint.namespace_stackable(:namespace))
-          end
-
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/grape/endpoint_render.rb

@@ -1,26 +0,0 @@
-module Skylight
-  module Normalizers
-    module Grape
-      class EndpointRender < Endpoint
-        register "endpoint_render.grape"
-
-        CAT = "app.grape.endpoint".freeze
-
-        def normalize(trace, name, payload)
-          if endpoint = payload[:endpoint]
-            path = get_path(endpoint)
-            namespace = get_namespace(endpoint)
-            method = get_method(endpoint)
-
-            title = [method, namespace, path].join(' ').gsub(/\s+/, ' ')
-
-            [CAT, title, nil]
-          else
-            :skip
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/grape/endpoint_run.rb

@@ -1,33 +0,0 @@
-module Skylight
-  module Normalizers
-    module Grape
-      class EndpointRun < Endpoint
-        register "endpoint_run.grape"
-
-        def normalize(trace, name, payload)
-          trace.endpoint = get_endpoint_name(payload[:endpoint]) if payload[:endpoint]
-
-          # We don't necessarily want this to be all instrumented since it's fairly internal.
-          # However, it is a good place to get the endpoint name.
-          :skip
-        end
-
-        private
-
-          def get_endpoint_name(endpoint)
-            method = get_method(endpoint)
-            path = get_path(endpoint)
-            namespace = get_namespace(endpoint)
-
-            if namespace && !namespace.empty?
-              path = "/#{path}" if path[0] != '/'
-              path = "#{namespace}#{path}"
-            end
-
-            "#{endpoint.options[:for]} [#{method}] #{path}"
-          end
-
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/grape/endpoint_run_filters.rb

@@ -1,23 +0,0 @@
-module Skylight
-  module Normalizers
-    module Grape
-      class EndpointRunFilters < Endpoint
-        register "endpoint_run_filters.grape"
-
-        CAT = "app.grape.filters".freeze
-
-        def normalize(trace, name, payload)
-          filters = payload[:filters]
-          type = payload[:type]
-
-          if (!filters || filters.empty?) || !type
-            return :skip
-          end
-
-          [CAT, "#{type.to_s.capitalize} Filters", nil]
-        end
-
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/moped/query.rb

@@ -1,100 +0,0 @@
-module Skylight
-  module Normalizers
-    module Moped
-      class Query < Normalizer
-        register "query.moped"
-
-        CAT = "db.mongo.query".freeze
-
-        # Normalizes a Moped operation
-        #
-        # @param trace [Skylight::Messages::Trace::Builder] ignored, only present to match API
-        # @param name [String] ignored, only present to match API
-        # @param payload [Hash]
-        # @option payload [Array<Moped::Protocol::*>] :ops array of performed operations. Supported operations are
-        #   `Query`, `GetMore`, `Insert`, `Update`, and `Delete`.
-        # @option payload [String] :prefix ignored, provided by Moped
-        # @return [Array, :skip] the normalized array or `:skip` if not a known operation type
-        def normalize(trace, name, payload)
-          # payload: { prefix: "  MOPED: #{address.resolved}", ops: operations }
-
-          # We can sometimes have multiple operations. However, it seems like this only happens when doing things
-          # like an insert, followed by a get last error, so we can probably ignore all but the first.
-          operation = payload[:ops] ? payload[:ops].first : nil
-          type = operation && operation.class.to_s =~ /^Moped::Protocol::(.+)$/ ? $1 : nil
-
-          case type
-          when "Query".freeze   then normalize_query(operation)
-          when "GetMore".freeze then normalize_get_more(operation)
-          when "Insert".freeze  then normalize_insert(operation)
-          when "Update".freeze  then normalize_update(operation)
-          when "Delete".freeze  then normalize_delete(operation)
-          else :skip
-          end
-        end
-
-      private
-
-        def normalize_query(operation)
-          title = normalize_title("QUERY".freeze, operation)
-
-          hash = extract_binds(operation.selector)
-          description = hash.to_json
-
-          [CAT, title, description]
-        end
-
-        def normalize_get_more(operation)
-          title = normalize_title("GET_MORE".freeze, operation)
-
-          [CAT, title, nil]
-        end
-
-        def normalize_insert(operation)
-          title = normalize_title("INSERT".freeze, operation)
-
-          [CAT, title, nil]
-        end
-
-        def normalize_update(operation)
-          title = normalize_title("UPDATE".freeze, operation)
-
-          selector_hash = extract_binds(operation.selector)
-          update_hash = extract_binds(operation.update)
-
-          description = { selector: selector_hash, update: update_hash }.to_json
-
-          [CAT, title, description]
-        end
-
-        def normalize_delete(operation)
-          title = normalize_title("DELETE".freeze, operation)
-
-          hash = extract_binds(operation.selector)
-          description = hash.to_json
-
-          [CAT, title, description]
-        end
-
-        def normalize_title(type, operation)
-          "#{type} #{operation.collection}"
-        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
-  end
-end

data/lib/skylight/probes.rb

@@ -1,129 +0,0 @@
-require 'pathname'
-
-module Skylight
-  # @api private
-  module Probes
-    class ProbeRegistration
-      attr_reader :name, :klass_name, :require_paths, :probe
-
-      def initialize(name, klass_name, require_paths, probe)
-        @name = name
-        @klass_name = klass_name
-        @require_paths = Array(require_paths)
-        @probe = probe
-      end
-
-      def install
-        probe.install
-      end
-    end
-
-    def self.available
-      unless @available
-        root = Pathname.new(File.expand_path("../probes", __FILE__))
-        @available = {}
-        Dir["#{root}/**/*.rb"].each do |f|
-          name = Pathname.new(f).relative_path_from(root).sub_ext('').to_s
-          @available[name] = "skylight/probes/#{name}"
-        end
-      end
-      @available
-    end
-
-    def self.probe(*probes)
-      unknown = probes.map(&:to_s) - available.keys
-      unless unknown.empty?
-        raise ArgumentError, "unknown probes: #{unknown.join(', ')}"
-      end
-
-      probes.each do |p|
-        begin
-          @via_api = true
-          require available[p.to_s]
-        ensure
-          @via_api = false
-        end
-      end
-    end
-
-    def self.require_hooks
-      @require_hooks ||= {}
-    end
-
-    def self.installed
-      @installed ||= {}
-    end
-
-    def self.is_available?(klass_name)
-      !!Skylight::Util::Inflector.safe_constantize(klass_name)
-    end
-
-    def self.register(name, *args)
-      unless @via_api
-        DEPRECATOR.deprecation_warning("Enabling probes via `require` alone",
-                                        "use `Skylight.probe(:#{name})` instead")
-      end
-
-      registration = ProbeRegistration.new(name, *args)
-
-      if is_available?(registration.klass_name)
-        installed[registration.klass_name] = registration
-        registration.install
-      else
-        register_require_hook(registration)
-      end
-    end
-
-    def self.require_hook(require_path)
-      return unless Skylight.native?
-
-      registration = lookup_by_require_path(require_path)
-      return unless registration
-
-      # Double check constant is available
-      if is_available?(registration.klass_name)
-        installed[registration.klass_name] = registration
-        registration.install
-
-        # Don't need this to be called again
-        unregister_require_hook(registration)
-      end
-    end
-
-    def self.register_require_hook(registration)
-      registration.require_paths.each do |p|
-        require_hooks[p] = registration
-      end
-    end
-
-    def self.unregister_require_hook(registration)
-      registration.require_paths.each do |p|
-        require_hooks.delete(p)
-      end
-    end
-
-    def self.lookup_by_require_path(require_path)
-      require_hooks[require_path]
-    end
-  end
-end
-
-# Allow hooking require
-# @api private
-module ::Kernel
-  private
-
-  alias require_without_sk require
-
-  def require(name)
-    ret = require_without_sk(name)
-
-    begin
-      Skylight::Probes.require_hook(name)
-    rescue Exception
-      # FIXME: Log these errors
-    end
-
-    ret
-  end
-end