skylight 4.2.2 → 5.0.0.beta2

data/lib/skylight/deprecation.rb

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

data/lib/skylight/errors.rb

@@ -1,4 +1,9 @@
+require "json"
+
 module Skylight
+  # @api private
+  class ConfigError < RuntimeError; end
+
   class NativeError < StandardError
     @classes = {}
 
@@ -29,13 +34,17 @@ module Skylight
       9999
     end
 
+    def self.formatted_code
+      format("%<code>04d", code: code)
+    end
+
     def self.message
       "Encountered an unknown internal error"
     end
 
     def initialize(method_name)
       @method_name = method_name
-      super(format("[E%<code>04d] %<message>s [%<meth>s]", code: code, message: message, meth: method_name))
+      super(format("[E%<code>04d] %<message>s [%<meth>s]", code: code, message: self.class.message, meth: method_name))
     end
 
     def code
@@ -43,9 +52,12 @@ module Skylight
     end
 
     def formatted_code
-      format("%04d", code)
+      self.class.formatted_code
     end
 
+    # E0002
+    # Too many unique descriptions - daemon only
+
     # E0003
     register(3, "MaximumTraceSpans", "Exceeded maximum number of spans in a trace.")
 
@@ -54,5 +66,8 @@ module Skylight
 
     # E0005
     register(5, "InstrumenterUnrecoverable", "Instrumenter is not running.")
+
+    # E0006
+    register(6, "InvalidUtf8", "Invalid UTF-8")
   end
 end

data/lib/skylight/extensions.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module Skylight
+  module Extensions
+    class Collection
+      def initialize(config, extensions = [])
+        @config = config
+        @extensions = extensions
+      end
+
+      def enable!(ext_name)
+        return if enabled?(ext_name)
+
+        find_by_name(ext_name) do |ext_class|
+          extensions << ext_class.new(config)
+          rememoize!
+        end
+      end
+
+      def disable!(ext_name)
+        find_by_name(ext_name) do |ext_class|
+          extensions.reject! { |x| x.is_a?(ext_class) }
+          rememoize!
+        end
+      end
+
+      def enabled?(ext_name)
+        return unless (ext_class = find_by_name(ext_name))
+
+        !!extensions.detect { |x| x.is_a?(ext_class) }
+      end
+
+      def process_trace_meta(meta)
+        extensions.each do |ext|
+          ext.process_trace_meta(meta)
+        end
+      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
+      end
+
+      def process_normalizer_meta(payload, meta, **opts)
+        extensions.each do |ext|
+          ext.process_normalizer_meta(payload, meta, **opts)
+        end
+      end
+
+      def trace_preprocess_meta(meta)
+        extensions.each do |ext|
+          ext.trace_preprocess_meta(meta)
+        end
+      end
+
+      def allowed_meta_keys
+        @allowed_meta_keys ||= extensions.flat_map(&:allowed_meta_keys).uniq
+      end
+
+      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
+
+        def rememoize!
+          @allowed_meta_keys = nil
+          allowed_meta_keys
+        end
+    end
+
+    class Extension
+      def initialize(config)
+        @config = config
+      end
+
+      def process_trace_meta(_meta); end
+
+      def process_instrument_options(_opts, _meta); end
+
+      def process_normalizer_meta(_payload, _meta, **opts); end
+
+      def trace_preprocess_meta(_meta); end
+
+      def allowed_meta_keys
+        []
+      end
+    end
+  end
+end
+
+require "skylight/extensions/source_location"

data/lib/skylight/extensions/source_location.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "skylight/util/lru_cache"
+require "active_support/dependencies"
+
+module Skylight
+  module Extensions
+    class SourceLocation < Extension
+      attr_reader :config
+
+      include Util::Logging
+
+      META_KEYS = %i[source_location source_file source_line].freeze
+
+      def initialize(*)
+        super
+        @caller_cache = Util::LruCache.new(100)
+        @instance_method_source_location_cache = Util::LruCache.new(100)
+        gem_require_trie # memoize this at startup
+      end
+
+      def process_trace_meta(meta)
+        unless meta[:source_location] || meta[:source_file]
+          warn "Ignoring source_line without source_file" if meta[:source_line]
+          if (location = find_caller)
+            meta[:source_file] = location.absolute_path
+            meta[:source_line] = location.lineno
+          end
+        end
+      end
+
+      def process_instrument_options(opts, meta)
+        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)
+
+        if source_location
+          meta[:source_location] = source_location
+        elsif source_name_hint
+          source_location = dispatch_hinted_source_location(source_name_hint, const_name, method_name)
+          meta[:source_file], meta[:source_line] = source_location
+          meta.delete(:source_location_hint) if source_location
+        elsif source_file
+          meta[:source_file] = source_file
+          meta[:source_line] = source_line
+        else
+          warn "Ignoring source_line without source_file" if source_line
+          if (location = find_caller(cache_key: opts.hash))
+            meta[:source_file] = location.absolute_path
+            meta[:source_line] = location.lineno
+          end
+        end
+
+        meta
+      end
+
+      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]}"
+        end
+
+        sl =
+          if (source_name, constant_name, method_name = opts[:source_location_hint])
+            dispatch_hinted_source_location(
+              source_name,
+              constant_name,
+              method_name
+            )
+          elsif opts[:source_file]
+            [opts[:source_file], opts[:source_line]]
+          end
+
+        sl ||= source_location(payload, meta, cache_key: opts[:cache_key])
+
+        if sl
+          debug("normalizer source_location=#{sl}")
+          meta[:source_file], meta[:source_line] = sl
+        end
+
+        meta
+      end
+
+      def trace_preprocess_meta(meta)
+        source_line = meta.delete(:source_line)
+        source_file = meta.delete(:source_file)
+
+        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}"
+          end
+
+          unless meta[:source_location].is_a?(String)
+            warn "Found non-string value for source_location; skipping"
+            meta.delete(:source_location)
+          end
+        elsif source_file
+          meta[:source_location] = sanitize_source_location(source_file, source_line)
+        elsif source_line
+          warn "Ignoring source_line without source_file; source_line=#{source_line}"
+        end
+
+        if meta[:source_location]
+          debug("source_location=#{meta[:source_location]}")
+        end
+      end
+
+      def allowed_meta_keys
+        META_KEYS
+      end
+
+      protected
+
+        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
+
+        # 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)
+          if cache_key
+            @caller_cache.fetch(cache_key) { find_caller_inner }
+          else
+            find_caller_inner
+          end
+        end
+
+        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/")
+
+          # 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
+              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
+            end
+          end
+        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
+          end
+
+          line ? "#{path}:#{line}" : path
+        end
+
+      private
+
+        def gem_require_trie
+          @gem_require_trie ||= begin
+            trie = {}
+
+            Gem.loaded_specs.each do |name, spec|
+              next if config.source_location_ignored_gems&.include?(name)
+
+              spec.full_require_paths.each do |path|
+                t1 = trie
+
+                path.split(File::SEPARATOR).each do |segment|
+                  t1[segment] ||= {}
+                  t1 = t1[segment]
+                end
+
+                t1[:name] = name
+              end
+            end
+
+            trie
+          end
+        end
+
+        def find_source_gem(path)
+          return nil unless path
+
+          trie = gem_require_trie
+
+          path.split(File::SEPARATOR).each do |segment|
+            trie = trie[segment]
+            break unless trie
+            return trie[:name] if trie[:name]
+          end
+
+          nil
+        end
+
+        def find_caller_inner
+          # Start at file before this one
+          # NOTE: We could start farther back now to avoid more Skylight files
+          caller_locations(1).find do |l|
+            find_source_gem(l.absolute_path) || project_path?(l.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))
+
+          while unbound_method.super_method
+            unbound_method = unbound_method.super_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))
+
+          while unbound_method.owner != constant && unbound_method.super_method
+            unbound_method = unbound_method.super_method
+          end
+
+          unbound_method if unbound_method.owner == constant
+        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