skylight 5.0.0.beta4 → 5.1.0.beta2

data/lib/skylight/deprecation.rb

@@ -3,14 +3,14 @@
 require "active_support/deprecation"
 
 module Skylight
-  SKYLIGHT_GEM_ROOT = "#{File.expand_path('../..', __dir__)}/"
+  SKYLIGHT_GEM_ROOT = "#{File.expand_path("../..", __dir__)}/"
 
   class Deprecation < ActiveSupport::Deprecation
     private
 
-      def ignored_callstack(path)
-        path.start_with?(SKYLIGHT_GEM_ROOT)
-      end
+    def ignored_callstack(path)
+      path.start_with?(SKYLIGHT_GEM_ROOT)
+    end
   end
 
   DEPRECATOR = Deprecation.new("6.0", "skylight")

data/lib/skylight/errors.rb

@@ -2,15 +2,14 @@ require "json"
 
 module Skylight
   # @api private
-  class ConfigError < RuntimeError; end
+  class ConfigError < RuntimeError
+  end
 
   class NativeError < StandardError
     @classes = {}
 
     def self.register(code, name, message)
-      if @classes.key?(code)
-        raise "Duplicate error class code: #{code}; name=#{name}"
-      end
+      raise "Duplicate error class code: #{code}; name=#{name}" if @classes.key?(code)
 
       Skylight.module_eval <<-RUBY, __FILE__, __LINE__ + 1
         class #{name}Error < NativeError            # class SqlLexError < NativeError

data/lib/skylight/extensions.rb

@@ -33,29 +33,21 @@ module Skylight
       end
 
       def process_trace_meta(meta)
-        extensions.each do |ext|
-          ext.process_trace_meta(meta)
-        end
+        extensions.each { |ext| ext.process_trace_meta(meta) }
       end
 
       # meta is a mutable hash that will be passed to the instrumenter.
       # This method bridges Skylight.instrument and instrumenter.instrument.
       def process_instrument_options(opts, meta)
-        extensions.each do |ext|
-          ext.process_instrument_options(opts, meta)
-        end
+        extensions.each { |ext| ext.process_instrument_options(opts, meta) }
       end
 
       def process_normalizer_meta(payload, meta, **opts)
-        extensions.each do |ext|
-          ext.process_normalizer_meta(payload, meta, **opts)
-        end
+        extensions.each { |ext| ext.process_normalizer_meta(payload, meta, **opts) }
       end
 
       def trace_preprocess_meta(meta)
-        extensions.each do |ext|
-          ext.trace_preprocess_meta(meta)
-        end
+        extensions.each { |ext| ext.trace_preprocess_meta(meta) }
       end
 
       def allowed_meta_keys
@@ -64,24 +56,20 @@ module Skylight
 
       private
 
-        attr_reader :extensions, :config
-
-        def find_by_name(ext_name)
-          begin
-            Skylight::Extensions.const_get(
-              ActiveSupport::Inflector.classify(ext_name)
-            )
-          rescue NameError
-            return nil
-          end.tap do |const|
-            yield const if block_given?
-          end
-        end
+      attr_reader :extensions, :config
 
-        def rememoize!
-          @allowed_meta_keys = nil
-          allowed_meta_keys
-        end
+      def find_by_name(ext_name)
+        begin
+          Skylight::Extensions.const_get(ActiveSupport::Inflector.classify(ext_name))
+        rescue NameError
+          return nil
+        end.tap { |const| yield const if block_given? }
+      end
+
+      def rememoize!
+        @allowed_meta_keys = nil
+        allowed_meta_keys
+      end
     end
 
     class Extension

data/lib/skylight/extensions/source_location.rb

@@ -35,8 +35,8 @@ module Skylight
         source_location = opts[:source_location] || opts[:meta]&.[](:source_location)
         source_file = opts[:source_file] || opts[:meta]&.[](:source_file)
         source_line = opts[:source_line] || opts[:meta]&.[](:source_line)
-        source_name_hint, const_name, method_name = opts[:source_location_hint] ||
-                                                    opts[:meta]&.[](:source_location_hint)
+        source_name_hint, const_name, method_name =
+          opts[:source_location_hint] || opts[:meta]&.[](:source_location_hint)
         instrument_location = opts[:sk_instrument_location]
 
         if source_location
@@ -65,16 +65,12 @@ module Skylight
       def process_normalizer_meta(payload, meta, **opts)
         if opts[:source_location] && (opts[:source_file] || opts[:source_line])
           warn "Found both source_location and source_file or source_line in normalizer\n" \
-              "  location=#{opts[:source_location]}; file=#{opts[:source_file]}; line=#{opts[:source_line]}"
+                 "  location=#{opts[:source_location]}; file=#{opts[:source_file]}; line=#{opts[:source_line]}"
         end
 
         sl =
           if (source_name, constant_name, method_name = opts[:source_location_hint])
-            dispatch_hinted_source_location(
-              source_name,
-              constant_name,
-              method_name
-            )
+            dispatch_hinted_source_location(source_name, constant_name, method_name)
           elsif opts[:source_file]
             [opts[:source_file], opts[:source_line]]
           end
@@ -82,7 +78,7 @@ module Skylight
         sl ||= source_location(payload, meta, cache_key: opts[:cache_key])
 
         if sl
-          debug("normalizer source_location=#{sl}")
+          trace("normalizer source_location=#{sl}")
           meta[:source_file], meta[:source_line] = sl
         end
 
@@ -96,7 +92,7 @@ module Skylight
         if meta[:source_location]
           if source_file || source_line
             warn "Found both source_location and source_file or source_line, using source_location\n" \
-                 "  location=#{meta[:source_location]}; file=#{source_file}; line=#{source_line}"
+                   "  location=#{meta[:source_location]}; file=#{source_file}; line=#{source_line}"
           end
 
           unless meta[:source_location].is_a?(String)
@@ -109,9 +105,7 @@ module Skylight
           warn "Ignoring source_line without source_file; source_line=#{source_line}"
         end
 
-        if meta[:source_location]
-          debug("source_location=#{meta[:source_location]}")
-        end
+        trace("source_location=#{meta[:source_location]}") if meta[:source_location]
       end
 
       def allowed_meta_keys
@@ -120,97 +114,101 @@ module Skylight
 
       protected
 
-        def dispatch_hinted_source_location(source_name, const_name, method_name)
-          return unless const_name && method_name
+      def dispatch_hinted_source_location(source_name, const_name, method_name)
+        return unless const_name && method_name
 
-          instance_method_source_location(const_name, method_name, source_name: source_name)
-        end
+        instance_method_source_location(const_name, method_name, source_name: source_name)
+      end
 
-        # from normalizers.rb
-        # Returns an array of file and line
-        def source_location(payload, meta, cache_key: nil)
-          # FIXME: what should precedence be?
-          if meta.is_a?(Hash) && meta[:source_location]
-            meta.delete(:source_location)
-          elsif payload.is_a?(Hash) && payload[:sk_source_location]
-            payload[:sk_source_location]
-          elsif (location = find_caller(cache_key: cache_key))
-            [location.absolute_path, location.lineno]
-          end
+      # from normalizers.rb
+      # Returns an array of file and line
+      def source_location(payload, meta, cache_key: nil)
+        # FIXME: what should precedence be?
+        if meta.is_a?(Hash) && meta[:source_location]
+          meta.delete(:source_location)
+        elsif payload.is_a?(Hash) && payload[:sk_source_location]
+          payload[:sk_source_location]
+        elsif (location = find_caller(cache_key: cache_key))
+          [location.absolute_path, location.lineno]
         end
+      end
 
-        def find_caller(cache_key: nil)
-          # starting at 4 to skip Skylight extension processing logic
-          locations = ::Kernel.caller_locations(4..MAX_CALLER_DEPTH)
+      def find_caller(cache_key: nil)
+        # starting at 4 to skip Skylight extension processing logic
+        locations = ::Kernel.caller_locations(4..MAX_CALLER_DEPTH)
 
-          if cache_key
-            localized_cache_key = [cache_key, locations.map(&:lineno)].hash
-            @caller_cache.fetch(localized_cache_key) { find_caller_inner(locations) }
-          else
-            find_caller_inner(locations)
-          end
+        if cache_key
+          localized_cache_key = [cache_key, locations.map(&:lineno)].hash
+          @caller_cache.fetch(localized_cache_key) { find_caller_inner(locations) }
+        else
+          find_caller_inner(locations)
         end
+      end
 
-        def project_path?(path)
-          return false unless path
+      def project_path?(path)
+        return false unless path
 
-          # Must be in the project root
-          return false unless path.start_with?(config.root.to_s)
-          # Must not be Bundler's vendor location
-          return false if defined?(Bundler) && path.start_with?(Bundler.bundle_path.to_s)
-          # Must not be Ruby files
-          return false if path.include?("/ruby-#{RUBY_VERSION}/lib/ruby/")
+        # Must be in the project root
+        return false unless path.start_with?(config.root.to_s)
 
-          # So it must be a project file
-          true
-        end
+        # Must not be Bundler's vendor location
+        return false if defined?(Bundler) && path.start_with?(Bundler.bundle_path.to_s)
 
-        def instance_method_source_location(constant_name, method_name, source_name: :instance_method)
-          @instance_method_source_location_cache.fetch([constant_name, method_name, source_name]) do
-            if (constant = ::ActiveSupport::Dependencies.safe_constantize(constant_name))
-              if constant.instance_methods.include?(:"before_instrument_#{method_name}")
-                method_name = :"before_instrument_#{method_name}"
-              end
-              begin
-                unbound_method = case source_name
-                                 when :instance_method
-                                   find_instance_method(constant, method_name)
-                                 when :own_instance_method
-                                   find_own_instance_method(constant, method_name)
-                                 when :instance_method_super
-                                   find_instance_method_super(constant, method_name)
-                                 when :class_method
-                                   find_class_method(constant, method_name)
-                                 end
-
-                unbound_method&.source_location
-              rescue NameError
-                nil
-              end
+        # Must not be Ruby files
+        return false if path.include?("/ruby-#{RUBY_VERSION}/lib/ruby/")
+
+        # So it must be a project file
+        true
+      end
+
+      def instance_method_source_location(constant_name, method_name, source_name: :instance_method)
+        @instance_method_source_location_cache.fetch([constant_name, method_name, source_name]) do
+          if (constant = ::ActiveSupport::Dependencies.safe_constantize(constant_name))
+            if constant.instance_methods.include?(:"before_instrument_#{method_name}")
+              method_name = :"before_instrument_#{method_name}"
             end
-          end
-        end
+            begin
+              unbound_method =
+                case source_name
+                when :instance_method
+                  find_instance_method(constant, method_name)
+                when :own_instance_method
+                  find_own_instance_method(constant, method_name)
+                when :instance_method_super
+                  find_instance_method_super(constant, method_name)
+                when :class_method
+                  find_class_method(constant, method_name)
+                end
 
-        def sanitize_source_location(path, line)
-          # Do this first since gems may be vendored in the app repo. However, it might be slower.
-          # Should we cache matches?
-          if (gem_name = find_source_gem(path))
-            path = gem_name
-            line = nil
-          elsif project_path?(path)
-            # Get relative path to root
-            path = Pathname.new(path).relative_path_from(config.root).to_s
-          else
-            return
+              unbound_method&.source_location
+            rescue NameError
+              nil
+            end
           end
+        end
+      end
 
-          line ? "#{path}:#{line}" : path
+      def sanitize_source_location(path, line)
+        # Do this first since gems may be vendored in the app repo. However, it might be slower.
+        # Should we cache matches?
+        if (gem_name = find_source_gem(path))
+          path = gem_name
+          line = nil
+        elsif project_path?(path)
+          # Get relative path to root
+          path = Pathname.new(path).relative_path_from(config.root).to_s
+        else
+          return
         end
 
+        line ? "#{path}:#{line}" : path
+      end
+
       private
 
-        def gem_require_trie
-          @gem_require_trie ||= begin
+      def gem_require_trie
+        @gem_require_trie ||=
+          begin
             trie = {}
 
             Gem.loaded_specs.each do |name, spec|
@@ -219,10 +217,12 @@ module Skylight
               spec.full_require_paths.each do |path|
                 t1 = trie
 
-                path.split(File::SEPARATOR).each do |segment|
-                  t1[segment] ||= {}
-                  t1 = t1[segment]
-                end
+                path
+                  .split(File::SEPARATOR)
+                  .each do |segment|
+                    t1[segment] ||= {}
+                    t1 = t1[segment]
+                  end
 
                 t1[:name] = name
               end
@@ -230,62 +230,62 @@ module Skylight
 
             trie
           end
-        end
+      end
 
-        def find_source_gem(path)
-          return nil unless path
+      def find_source_gem(path)
+        return nil unless path
 
-          trie = gem_require_trie
+        trie = gem_require_trie
 
-          path.split(File::SEPARATOR).each do |segment|
+        path
+          .split(File::SEPARATOR)
+          .each do |segment|
             trie = trie[segment]
             break unless trie
             return trie[:name] if trie[:name]
           end
 
-          nil
-        end
+        nil
+      end
 
-        def find_caller_inner(locations)
-          # Start at file before this one
-          # NOTE: We could start farther back now to avoid more Skylight files
-          locations.find do |l|
-            absolute_path = l.absolute_path
-            find_source_gem(absolute_path) || project_path?(absolute_path)
-          end
+      def find_caller_inner(locations)
+        # Start at file before this one
+        # NOTE: We could start farther back now to avoid more Skylight files
+        locations.find do |l|
+          absolute_path = l.absolute_path
+          find_source_gem(absolute_path) || project_path?(absolute_path)
         end
+      end
 
-        # walks up the inheritance tree until it finds the last method
-        # without a super_method definition.
-        def find_instance_method_super(constant, method_name)
-          return unless (unbound_method = find_instance_method(constant, method_name))
+      # walks up the inheritance tree until it finds the last method
+      # without a super_method definition.
+      def find_instance_method_super(constant, method_name)
+        return unless (unbound_method = find_instance_method(constant, method_name))
 
-          while unbound_method.super_method
-            unbound_method = unbound_method.super_method
-          end
+        unbound_method = unbound_method.super_method while unbound_method.super_method
 
-          unbound_method
-        end
+        unbound_method
+      end
 
-        # walks up the inheritance tree until it finds the instance method
-        # belonging to the constant given (skip prepended modules)
-        def find_own_instance_method(constant, method_name)
-          return unless (unbound_method = find_instance_method(constant, method_name))
+      # walks up the inheritance tree until it finds the instance method
+      # belonging to the constant given (skip prepended modules)
+      def find_own_instance_method(constant, method_name)
+        return unless (unbound_method = find_instance_method(constant, method_name))
 
-          while unbound_method.owner != constant && unbound_method.super_method
-            unbound_method = unbound_method.super_method
-          end
-
-          unbound_method if unbound_method.owner == constant
+        while unbound_method.owner != constant && unbound_method.super_method
+          unbound_method = unbound_method.super_method
         end
 
-        def find_instance_method(constant, method_name)
-          constant.instance_method(method_name)
-        end
+        unbound_method if unbound_method.owner == constant
+      end
 
-        def find_class_method(constant, method_name)
-          constant.method(method_name)
-        end
+      def find_instance_method(constant, method_name)
+        constant.instance_method(method_name)
+      end
+
+      def find_class_method(constant, method_name)
+        constant.method(method_name)
+      end
     end
   end
 end