skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/deprecation.rb

@@ -1,55 +0,0 @@
-require 'active_support/deprecation'
-
-module Skylight
-  SKYLIGHT_GEM_ROOT = File.expand_path("../../..", __FILE__) + "/"
-
-  if ActiveSupport::Deprecation.respond_to?(:new)
-    class Deprecation < ActiveSupport::Deprecation
-      private
-
-        def ignored_callstack(path)
-          path.start_with?(SKYLIGHT_GEM_ROOT)
-        end
-    end
-  else
-    # Rails 3.x
-    class Deprecation
-      attr_accessor :silenced
-      attr_reader :deprecation_horizon, :gem_name
-
-      def initialize(deprecation_horizon, gem_name)
-        @deprecation_horizon = deprecation_horizon
-        @gem_name = gem_name
-      end
-
-      # Silence deprecation warnings within the block.
-      def silence
-        old_silenced, @silenced = @silenced, true
-        yield
-      ensure
-        @silenced = old_silenced
-      end
-
-      def deprecation_warning(deprecated_method_name, message = nil)
-        return if silenced
-
-        msg = "#{deprecated_method_name} is deprecated and will be removed from #{gem_name} #{deprecation_horizon}"
-        case message
-          when Symbol then msg << " (use #{message} instead)"
-          when String then msg << " (#{message})"
-        end
-
-        ActiveSupport::Deprecation.warn(msg, extract_callstack(caller))
-      end
-
-      private
-
-        def extract_callstack(callstack)
-          filtered = callstack.reject { |line| line.start_with?(SKYLIGHT_GEM_ROOT) }
-          filtered.empty? ? callstack : filtered
-        end
-    end
-  end
-
-  DEPRECATOR = Deprecation.new('2.0', 'skylight')
-end

data/lib/skylight/formatters/http.rb

@@ -1,20 +0,0 @@
-module Skylight
-  module Formatters
-    module HTTP
-
-      # Build instrumentation options for HTTP queries
-      #
-      # @param [String] method HTTP method, e.g. get, post
-      # @param [String] scheme HTTP scheme, e.g. http, https
-      # @param [String] host Request host, e.g. example.com
-      # @param [String, Integer] port Request port
-      # @param [String] path Request path
-      # @param [String] query Request query string
-      # @return [Hash] a hash containing `:category`, `:title`, and `:annotations`
-      def self.build_opts(method, scheme, host, port, path, query)
-        { category: "api.http.#{method.downcase}",
-          title:    "#{method.upcase} #{host}" }
-      end
-    end
-  end
-end

data/lib/skylight/gc.rb

@@ -1,107 +0,0 @@
-require 'thread'
-
-module Skylight
-  # @api private
-  class GC
-    METHODS   = [ :enable, :total_time ]
-    TH_KEY    = :SK_GC_CURR_WINDOW
-    MAX_COUNT = 1000
-    MAX_TIME  = 30_000_000
-
-    include Util::Logging
-
-    attr_reader :config
-
-    def initialize(config, profiler)
-      @listeners = []
-      @config    = config
-      @lock      = Mutex.new
-      @time      = 0
-
-      if METHODS.all? { |m| profiler.respond_to?(m) }
-        @profiler = profiler
-        @time = @profiler.total_time
-      else
-        debug "disabling GC profiling"
-      end
-    end
-
-    def enable
-      @profiler.enable if @profiler
-    end
-
-    def track
-      unless @profiler
-        win = Window.new(nil)
-      else
-        win = Window.new(self)
-
-        @lock.synchronize do
-          __update
-          @listeners << win
-
-          # Cleanup any listeners that might have leaked
-          until @listeners[0].time < MAX_TIME
-            @listeners.shift
-          end
-
-          if @listeners.length > MAX_COUNT
-            @listeners.shift
-          end
-        end
-      end
-
-      win
-    end
-
-    def release(win)
-      @lock.synchronize do
-        @listeners.delete(win)
-      end
-    end
-
-    def update
-      @lock.synchronize do
-        __update
-      end
-
-      nil
-    end
-
-  private
-
-    def __update
-      time  = @profiler.total_time
-      diff  = time - @time
-      @time = time
-
-      if diff > 0
-        @listeners.each do |l|
-          l.add(diff)
-        end
-      end
-    end
-
-    class Window
-      attr_reader :time
-
-      def initialize(global)
-        @global = global
-        @time   = 0
-      end
-
-      def update
-        @global.update if @global
-      end
-
-      def add(time)
-        @time += time
-      end
-
-      def release
-        @global.release(self) if @global
-      end
-    end
-
-  end
-end

data/lib/skylight/normalizers.rb

@@ -1,192 +0,0 @@
-require 'skylight/normalizers/default'
-
-module Skylight
-  # @api private
-  # Convert AS::N events to Skylight events
-  module Normalizers
-
-    DEFAULT = Default.new
-
-    def self.registry
-      @registry ||= {}
-    end
-
-    def self.register(name, klass, opts)
-      enabled = opts[:enabled] != false
-      registry[name] = [klass, enabled]
-    end
-
-    def self.enable(*names)
-      names.each do |name|
-        matches = registry.select{|n,_| n =~ /(^|\.)#{name}$/ }
-        raise ArgumentError, "no normalizers match #{name}" if matches.empty?
-        matches.each{|k,v| v[1] = true }
-      end
-    end
-
-    def self.build(config)
-      normalizers = {}
-
-      registry.each do |key, (klass, enabled)|
-        if !enabled
-          # For now we use anyway, but in 2.0 we'll stop using disabled normalizers
-          DEPRECATOR.deprecation_warning("Enabling non-default normalizers via `require`",
-            "use `Skylight.enable_normalizer('#{key}')` instead")
-        end
-
-        unless klass.method_defined?(:normalize)
-          # TODO: Warn
-          next
-        end
-
-        normalizers[key] = klass.new(config)
-      end
-
-      Container.new(normalizers)
-    end
-
-    class Normalizer
-      def self.register(name, opts={})
-        Normalizers.register(name, self, opts)
-      end
-
-      attr_reader :config
-
-      def initialize(config)
-        @config = config
-        setup if respond_to?(:setup)
-      end
-
-      def normalize(trace, name, payload)
-        :skip
-      end
-
-      def normalize_after(trace, span, name, payload)
-      end
-    end
-
-    # FIXME: Move this elsewhere
-    # Base Normalizer for Rails rendering
-    class RenderNormalizer < Normalizer
-      include Util::AllocationFree
-
-      def setup
-        @paths = config['normalizers.render.view_paths'] || []
-      end
-
-      # Generic normalizer for renders
-      # @param category [String]
-      # @param payload [Hash]
-      # @option payload [String] :identifier
-      # @return [Array]
-      def normalize_render(category, payload)
-        if path = payload[:identifier]
-          title = relative_path(path)
-          path = nil if path == title
-        end
-
-        [ category, title, nil ]
-      end
-
-      def relative_path(path)
-        return path if relative_path?(path)
-
-        root = array_find(@paths) { |p| path.start_with?(p) }
-        type = :project
-
-        unless root
-          root = array_find(Gem.path) { |p| path.start_with?(p) }
-          type = :gem
-        end
-
-        if root
-          start = root.size
-          start += 1 if path.getbyte(start) == SEPARATOR_BYTE
-          if type == :gem
-            "$GEM_PATH/#{path[start, path.size]}"
-          else
-            path[start, path.size]
-          end
-        else
-          "Absolute Path"
-        end
-      end
-
-    private
-      def relative_path?(path)
-        !absolute_path?(path)
-      end
-
-      SEPARATOR_BYTE = File::SEPARATOR.ord
-
-      if File.const_defined?(:NULL) ? File::NULL == "NUL" : RbConfig::CONFIG['host_os'] =~ /mingw|mswin32/
-        # This is a DOSish environment
-        ALT_SEPARATOR_BYTE = File::ALT_SEPARATOR && File::ALT_SEPARATOR.ord
-        COLON_BYTE = ":".ord
-        def absolute_path?(path)
-          if alpha?(path.getbyte(0)) && path.getbyte(1) == COLON_BYTE
-            byte2 = path.getbyte(2)
-            byte2 == SEPARATOR_BYTE || byte2 == ALT_SEPARATOR_BYTE
-          end
-        end
-
-        def alpha?(byte)
-          byte >= 65 and byte <= 90 || byte >= 97 and byte <= 122
-        end
-      else
-        def absolute_path?(path)
-          path.getbyte(0) == SEPARATOR_BYTE
-        end
-      end
-    end
-
-    class Container
-      def initialize(normalizers)
-        @normalizers = normalizers
-      end
-
-      def keys
-        @normalizers.keys
-      end
-
-      def normalize(trace, name, payload)
-        normalizer_for(name).normalize(trace, name, payload)
-      end
-
-      def normalize_after(trace, span, name, payload)
-        normalizer_for(name).normalize_after(trace, span, name, payload)
-      end
-
-      def normalizer_for(name)
-        @normalizers[name] || DEFAULT
-      end
-    end
-
-    %w( action_controller/process_action
-        action_controller/send_file
-        action_view/render_collection
-        action_view/render_partial
-        action_view/render_template
-        active_model_serializers/render
-        active_record/instantiation
-        active_record/sql
-        active_support/cache
-        elasticsearch/request
-        grape/endpoint
-        moped/query
-        faraday/request
-        couch_potato/query).each do |file|
-      require "skylight/normalizers/#{file}"
-    end
-
-    # Coach instrumentation is only available in Ruby 2+
-    if RUBY_VERSION.split.first.to_i > 1
-      %w(coach/handler_finish coach/middleware_finish).each do |file|
-        require "skylight/normalizers/#{file}"
-      end
-    end
-
-    # The following are not required by default as they are of dubious usefulness:
-    # - active_job/enqueue_at
-  end
-end

data/lib/skylight/normalizers/action_controller/process_action.rb

@@ -1,50 +0,0 @@
-module Skylight
-  module Normalizers
-    module ActionController
-      # Normalizer for processing a Rails controller action
-      class ProcessAction < Normalizer
-        register "process_action.action_controller"
-
-        CAT = "app.controller.request".freeze
-
-        # Payload Keys: controller, action, params, format, method, path
-        #   Additional keys available in `normalize_after`: status, view_runtime
-        #     Along with ones added by probe: variant
-
-        # @param trace [Skylight::Messages::Trace::Builder]
-        # @param name [String] ignored, only present to match API
-        # @param payload [Hash]
-        # @option payload [String] :controller Controller name
-        # @option payload [String] :action Action name
-        # @return [Array]
-        def normalize(trace, name, payload)
-          trace.endpoint = controller_action(payload)
-          [ CAT, trace.endpoint, nil ]
-        end
-
-        def normalize_after(trace, span, name, payload)
-          return unless config.enable_segments?
-
-          # Show 'error' if there's an unhandled exception or if the status is 4xx or 5xx
-          if payload[:exception] || payload[:status].to_s =~ /^[45]/
-            segment = "error"
-          # We won't have a rendered_format if it's a `head` outside of a `respond_to` block.
-          elsif payload[:rendered_format]
-            # We only show the variant if we actually have a format
-            segment = [payload[:rendered_format], payload[:variant]].compact.flatten.join('+')
-          end
-
-          if segment
-            trace.endpoint += "<sk-segment>#{segment}</sk-segment>"
-          end
-        end
-
-      private
-
-        def controller_action(payload)
-          "#{payload[:controller]}##{payload[:action]}"
-        end
-      end
-    end
-  end
-end

data/lib/skylight/normalizers/action_controller/send_file.rb

@@ -1,50 +0,0 @@
-module Skylight
-  module Normalizers
-    module ActionController
-
-      # Temporary hacks
-      begin
-        require "action_dispatch/http/mime_type"
-        require "action_dispatch/http/mime_types"
-        require "rack/utils"
-
-        class SendFile < Normalizer
-          register "send_file.action_controller"
-
-          CAT = "app.controller.send_file".freeze
-          TITLE = "send file".freeze
-
-          def normalize(trace, name, payload)
-            path = payload[:path]
-
-            title = TITLE
-
-            # depending on normalization, we probably want this to eventually
-            # include the full path, but we need to make sure we have a good
-            # deduping strategy first.
-            desc = nil
-
-            [ CAT, title, desc ]
-          end
-
-        private
-
-          OCTET_STREAM = "application/octet-stream".freeze
-          ATTACHMENT = "attachment".freeze
-
-          def initialize(*)
-            super
-
-            @mimes = Mime::SET.reduce({}) do |hash, mime|
-              hash[mime.symbol] = mime.to_s.dup.freeze
-              hash
-            end
-          end
-        end
-
-      rescue LoadError
-      end
-
-    end
-  end
-end