skylight 5.0.0.beta4 → 5.1.0.beta2

data/lib/skylight/formatters/http.rb

@@ -11,9 +11,7 @@ module Skylight
       # @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}",
-          internal: true }
+        { category: "api.http.#{method.downcase}", title: "#{method.upcase} #{host}", internal: true }
       end
     end
   end

data/lib/skylight/gc.rb

@@ -3,10 +3,10 @@ require "skylight/util/logging"
 module Skylight
   # @api private
   class GC
-    METHODS   = %i[enable total_time].freeze
-    TH_KEY    = :SK_GC_CURR_WINDOW
+    METHODS = %i[enable total_time].freeze
+    TH_KEY = :SK_GC_CURR_WINDOW
     MAX_COUNT = 1000
-    MAX_TIME  = 30_000_000
+    MAX_TIME = 30_000_000
 
     include Util::Logging
 
@@ -14,9 +14,9 @@ module Skylight
 
     def initialize(config, profiler)
       @listeners = []
-      @config    = config
-      @lock      = Mutex.new
-      @time      = 0
+      @config = config
+      @lock = Mutex.new
+      @time = 0
 
       if METHODS.all? { |m| profiler.respond_to?(m) }
         @profiler = profiler
@@ -46,9 +46,7 @@ module Skylight
           # Cleanup any listeners that might have leaked
           @listeners.shift until @listeners[0].time < MAX_TIME
 
-          if @listeners.length > MAX_COUNT
-            @listeners.shift
-          end
+          @listeners.shift if @listeners.length > MAX_COUNT
         end
 
         win
@@ -58,52 +56,44 @@ module Skylight
     end
 
     def release(win)
-      @lock.synchronize do
-        @listeners.delete(win)
-      end
+      @lock.synchronize { @listeners.delete(win) }
     end
 
     def update
-      @lock.synchronize do
-        __update
-      end
+      @lock.synchronize { __update }
 
       nil
     end
 
     private
 
-      def __update
-        time  = @profiler.total_time
-        diff  = time - @time
-        @time = time
+    def __update
+      time = @profiler.total_time
+      diff = time - @time
+      @time = time
 
-        if diff > 0
-          @listeners.each do |l|
-            l.add(diff)
-          end
-        end
-      end
+      @listeners.each { |l| l.add(diff) } if diff > 0
+    end
 
-      class Window
-        attr_reader :time
+    class Window
+      attr_reader :time
 
-        def initialize(global)
-          @global = global
-          @time   = 0
-        end
+      def initialize(global)
+        @global = global
+        @time = 0
+      end
 
-        def update
-          @global&.update
-        end
+      def update
+        @global&.update
+      end
 
-        def add(time)
-          @time += time
-        end
+      def add(time)
+        @time += time
+      end
 
-        def release
-          @global&.release(self)
-        end
+      def release
+        @global&.release(self)
       end
+    end
   end
 end

data/lib/skylight/helpers.rb

@@ -14,7 +14,7 @@ module Skylight
 
         if (opts = @__sk_instrument_next_method)
           @__sk_instrument_next_method = nil
-          instrument_method(name, opts)
+          instrument_method(name, **opts)
         end
       end
 
@@ -24,7 +24,7 @@ module Skylight
 
         if (opts = @__sk_instrument_next_method)
           @__sk_instrument_next_method = nil
-          instrument_class_method(name, opts)
+          instrument_class_method(name, **opts)
         end
       end
 
@@ -77,14 +77,12 @@ module Skylight
       #         do_expensive_stuff
       #       end
       #     end
-      def instrument_method(*args)
-        opts = args.pop if args.last.is_a?(Hash)
-
+      def instrument_method(*args, **opts)
         if (name = args.pop)
           title = "#{self}##{name}"
-          __sk_instrument_method_on(self, name, title, opts || {})
+          __sk_instrument_method_on(self, name, title, **opts)
         else
-          @__sk_instrument_next_method = opts || {}
+          @__sk_instrument_next_method = opts
         end
       end
 
@@ -123,32 +121,58 @@ module Skylight
       #
       #       instrument_class_method :my_method, title: 'Expensive work'
       #     end
-      def instrument_class_method(name, opts = {})
+      def instrument_class_method(name, **opts)
         # NOTE: If the class is defined anonymously and then assigned to a variable this code
         #   will not be aware of the updated name.
         title = "#{self}.#{name}"
-        __sk_instrument_method_on(__sk_singleton_class, name, title, opts || {})
+        __sk_instrument_method_on(__sk_singleton_class, name, title, **opts)
       end
 
       private
 
-        def __sk_instrument_method_on(klass, name, title, opts)
-          category = (opts[:category] || "app.method").to_s
-          title    = (opts[:title] || title).to_s
-          desc     = opts[:description].to_s if opts[:description]
+      HAS_ARGUMENT_FORWARDING = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
+
+      def __sk_instrument_method_on(klass, name, title, **opts)
+        category = (opts[:category] || "app.method").to_s
+        title = (opts[:title] || title).to_s
+        desc = opts[:description].to_s if opts[:description]
+
+        # NOTE: The source location logic happens before we have have a config so we can'
+        # check if source locations are enabled. However, it only happens once so the potential impact
+        # should be minimal. This would more appropriately belong to Extensions::SourceLocation,
+        # but as that is a runtime concern, and this happens at compile time, there isn't currently
+        # a clean way to turn this on and off. The absence of the extension will cause the
+        # source_file and source_line to be removed from the trace span before it is submitted.
+        source_file, source_line = klass.instance_method(name).source_location
+
+        # We should strongly prefer using the new argument-forwarding syntax (...) where available.
+        # In Ruby 2.7, the following are known to be syntax errors:
+        #
+        # - mixing positional arguments with argument forwarding (e.g., send(:method_name, ...))
+        # - calling a setter method with multiple arguments, unless dispatched via send or public_send.
+        #
+        # So it is possible, though not recommended, to define setter methods that take multiple arguments,
+        # keywords, and/or blocks. Unfortunately, this means that for setters, we still need to explicitly
+        # forward the different argument types.
+        is_setter_method = name.to_s.end_with?("=")
 
-          # NOTE: The source location logic happens before we have have a config so we can'
-          # check if source locations are enabled. However, it only happens once so the potential impact
-          # should be minimal. This would more appropriately belong to Extensions::SourceLocation,
-          # but as that is a runtime concern, and this happens at compile time, there isn't currently
-          # a clean way to turn this on and off. The absence of the extension will cause the
-          # source_file and source_line to be removed from the trace span before it is submitted.
-          source_file, source_line = klass.instance_method(name).source_location
+        arg_string =
+          if HAS_ARGUMENT_FORWARDING
+            is_setter_method ? "*args, **kwargs, &blk" : "..."
+          else
+            "*args, &blk"
+          end
+
+        original_method_dispatch =
+          if is_setter_method
+            "self.send(:before_instrument_#{name}, #{arg_string})"
+          else
+            "before_instrument_#{name}(#{arg_string})"
+          end
 
-          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             alias_method :"before_instrument_#{name}", :"#{name}"       # alias_method :"before_instrument_process", :"process"
-                                                                        #
-            def #{name}(*args, &blk)                                    # def process(*args, &blk)
+            def #{name}(#{arg_string})                                  # def process(*args, **kwargs, &blk)
               span = Skylight.instrument(                               #   span = Skylight.instrument(
                 category:    :"#{category}",                            #     category:    :"app.method",
                 title:       #{title.inspect},                          #     title:       "process",
@@ -157,8 +181,9 @@ module Skylight
                 source_line: #{source_line.inspect})                    #     source_line: 123)
                                                                         #
               meta = {}                                                 #   meta = {}
+                                                                        #
               begin                                                     #   begin
-                send(:before_instrument_#{name}, *args, &blk)           #     send(:before_instrument_process)
+                #{original_method_dispatch}                             #     self.before_instrument_process(...)
               rescue Exception => e                                     #   rescue Exception => e
                 meta[:exception_object] = e                             #     meta[:exception_object] = e
                 raise e                                                 #     raise e
@@ -173,15 +198,17 @@ module Skylight
               private :"#{name}"                                        #   private :"process"
             end                                                         # end
           RUBY
-        end
+      end
 
-        if respond_to?(:singleton_class)
-          alias __sk_singleton_class singleton_class
-        else
-          def __sk_singleton_class
-            class << self; self; end
+      if respond_to?(:singleton_class)
+        alias __sk_singleton_class singleton_class
+      else
+        def __sk_singleton_class
+          class << self
+            self
           end
         end
+      end
     end
 
     # @api private

data/lib/skylight/instrumenter.rb

@@ -99,16 +99,14 @@ module Skylight
     end
 
     def current_trace=(trace)
-      t { "setting current_trace=#{trace ? trace.uuid : 'nil'}; thread=#{Thread.current.object_id}" }
+      t { "setting current_trace=#{trace ? trace.uuid : "nil"}; thread=#{Thread.current.object_id}" }
       @trace_info.current = trace
     end
 
     def validate_installation
       # Warn if there was an error installing Skylight.
 
-      if defined?(Skylight.check_install_errors)
-        Skylight.check_install_errors(config)
-      end
+      Skylight.check_install_errors(config) if defined?(Skylight.check_install_errors)
 
       if !Skylight.native? && defined?(Skylight.warn_skylight_native_missing)
         Skylight.warn_skylight_native_missing(config)
@@ -143,9 +141,7 @@ module Skylight
     end
 
     def silence_warnings(context)
-      @warnings_silenced || @mutex.synchronize do
-        @warnings_silenced ||= {}
-      end
+      @warnings_silenced || @mutex.synchronize { @warnings_silenced ||= {} }
 
       @warnings_silenced[context] = true
     end
@@ -203,8 +199,18 @@ module Skylight
       begin
         meta ||= {}
         extensions.process_trace_meta(meta)
-        trace = Trace.new(self, endpoint, Skylight::Util::Clock.nanos, cat, title, desc,
-                          meta: meta, segment: segment, component: component)
+        trace =
+          Trace.new(
+            self,
+            endpoint,
+            Skylight::Util::Clock.nanos,
+            cat,
+            title,
+            desc,
+            meta: meta,
+            segment: segment,
+            component: component
+          )
       rescue Exception => e
         log_error e.message
         t { e.backtrace.join("\n") }
@@ -301,7 +307,7 @@ module Skylight
         finalize_endpoint_segment(trace)
         native_submit_trace(trace)
         true
-      rescue => e
+      rescue StandardError => e
         handle_instrumenter_error(trace, e)
       end
     end
@@ -332,14 +338,15 @@ module Skylight
     def finalize_endpoint_segment(trace)
       return unless (segment = trace.segment)
 
-      segment = case trace.compound_response_error_status
-                when :all
-                  "error"
-                when :partial
-                  "#{segment}+error"
-                else
-                  segment
-                end
+      segment =
+        case trace.compound_response_error_status
+        when :all
+          "error"
+        when :partial
+          "#{segment}+error"
+        else
+          segment
+        end
 
       trace.endpoint += "<sk-segment>#{segment}</sk-segment>"
     end

data/lib/skylight/middleware.rb

@@ -49,12 +49,16 @@ module Skylight
     def self.with_after_close(resp, debug_identifier: "unknown", &block)
       unless resp.respond_to?(:to_ary)
         if resp.respond_to?(:to_a)
-          Skylight.warn("Rack response from \"#{debug_identifier}\" cannot be implicitly converted to an array. " \
-                        "This is in violation of the Rack SPEC and will raise an error in future versions.")
+          Skylight.warn(
+            "Rack response from \"#{debug_identifier}\" cannot be implicitly converted to an array. " \
+              "This is in violation of the Rack SPEC and will raise an error in future versions."
+          )
           resp = resp.to_a
         else
-          Skylight.error("Rack response from \"#{debug_identifier}\" cannot be converted to an array. This is in " \
-                         "violation of the Rack SPEC and may cause problems with Skylight operation.")
+          Skylight.error(
+            "Rack response from \"#{debug_identifier}\" cannot be converted to an array. This is in " \
+              "violation of the Rack SPEC and may cause problems with Skylight operation."
+          )
           return resp
         end
       end
@@ -91,11 +95,7 @@ module Skylight
 
           resp = @app.call(env)
 
-          if trace
-            Middleware.with_after_close(resp, debug_identifier: "Rack App: #{@app.class}") { trace.submit }
-          else
-            resp
-          end
+          trace ? Middleware.with_after_close(resp, debug_identifier: "Rack App: #{@app.class}") { trace.submit } : resp
         rescue Exception => e
           t { "middleware exception: #{e}\n#{e.backtrace.join("\n")}" }
           trace&.submit
@@ -106,36 +106,32 @@ module Skylight
 
     private
 
-      def log_context
-        # Don't cache this, it will change
-        { request_id: @current_request_id, inst: Skylight.instrumenter&.uuid }
-      end
+    def log_context
+      # Don't cache this, it will change
+      { request_id: @current_request_id, inst: Skylight.instrumenter&.uuid }
+    end
 
-      # Allow for overwriting
-      def endpoint_name(_env)
-        "Rack"
-      end
+    # Allow for overwriting
+    def endpoint_name(_env)
+      "Rack"
+    end
 
-      def endpoint_meta(_env)
-        { source_location: Trace::SYNTHETIC }
-      end
+    def endpoint_meta(_env)
+      { source_location: Trace::SYNTHETIC }
+    end
 
-      # Request ID code based on ActionDispatch::RequestId
-      def set_request_id(env)
-        existing_request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
-        @current_request_id = env["skylight.request_id"] = make_request_id(existing_request_id)
-      end
+    # Request ID code based on ActionDispatch::RequestId
+    def set_request_id(env)
+      existing_request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
+      @current_request_id = env["skylight.request_id"] = make_request_id(existing_request_id)
+    end
 
-      def make_request_id(request_id)
-        if request_id && !request_id.empty?
-          request_id.gsub(/[^\w\-]/, "".freeze)[0...255]
-        else
-          internal_request_id
-        end
-      end
+    def make_request_id(request_id)
+      request_id && !request_id.empty? ? request_id.gsub(/[^\w\-]/, "".freeze)[0...255] : internal_request_id
+    end
 
-      def internal_request_id
-        SecureRandom.uuid
-      end
+    def internal_request_id
+      SecureRandom.uuid
+    end
   end
 end

data/lib/skylight/native.rb

@@ -105,20 +105,18 @@ module Skylight
     install_log = File.expand_path("../../ext/install.log", __dir__)
 
     if File.exist?(install_log) && File.read(install_log) =~ /ERROR/
-      config.alert_logger.error \
-        "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension failed to install. " \
-        "Please check #{install_log} and notify support@skylight.io. " \
-        "The missing extension will not affect the functioning of your application."
+      config.alert_logger.error "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension failed to install. " \
+                                  "Please check #{install_log} and notify support@skylight.io. " \
+                                  "The missing extension will not affect the functioning of your application."
     end
   end
 
   # @api private
   def self.warn_skylight_native_missing(config)
-    config.alert_logger.error \
-      "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for " \
-      "your platform wasn't found. Supported operating systems are " \
-      "Linux 2.6.18+ and Mac OS X 10.8+. The missing extension will not " \
-      "affect the functioning of your application. If you are on a " \
-      "supported platform, please contact support at support@skylight.io."
+    config.alert_logger.error "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for " \
+                                "your platform wasn't found. Supported operating systems are " \
+                                "Linux 2.6.18+ and Mac OS X 10.8+. The missing extension will not " \
+                                "affect the functioning of your application. If you are on a " \
+                                "supported platform, please contact support at support@skylight.io."
   end
 end