skylight 5.1.1 → 5.3.3

data/lib/skylight/errors.rb

@@ -68,5 +68,8 @@ module Skylight
 
     # E0006
     register(6, "InvalidUtf8", "Invalid UTF-8")
+
+    # E0007
+    register(7, "GrpcConnect", "Failed to connect to gRPC server.")
   end
 end

data/lib/skylight/extensions/source_location.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "skylight/util/lru_cache"
-require "active_support/dependencies"
+require "active_support/inflector"
 
 module Skylight
   module Extensions
@@ -163,7 +163,7 @@ module Skylight
 
       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 = ::ActiveSupport::Inflector.safe_constantize(constant_name))
             if constant.instance_methods.include?(:"before_instrument_#{method_name}")
               method_name = :"before_instrument_#{method_name}"
             end

data/lib/skylight/instrumenter.rb

@@ -36,7 +36,7 @@ module Skylight
       end
     end
 
-    attr_reader :uuid, :config, :gc, :extensions
+    attr_reader :uuid, :config, :gc, :extensions, :subscriber
 
     def self.native_new(_uuid, _config_env)
       raise "not implemented"

data/lib/skylight/middleware.rb

@@ -3,6 +3,8 @@ require "securerandom"
 module Skylight
   # @api private
   class Middleware
+    SKYLIGHT_REQUEST_ID = "skylight.request_id".freeze
+
     class BodyProxy
       def initialize(body, &block)
         @body = body
@@ -81,7 +83,8 @@ module Skylight
       set_request_id(env)
 
       if Skylight.tracing?
-        error "Already instrumenting. Make sure the Skylight Rack Middleware hasn't been added more than once."
+        debug "Already instrumenting. Make sure the Skylight Rack Middleware hasn't been added more than once."
+        return @app.call(env)
       end
 
       if env["REQUEST_METHOD"] == "HEAD"
@@ -108,7 +111,7 @@ module Skylight
 
     def log_context
       # Don't cache this, it will change
-      { request_id: @current_request_id, inst: Skylight.instrumenter&.uuid }
+      { request_id: current_request_id, inst: Skylight.instrumenter&.uuid }
     end
 
     # Allow for overwriting
@@ -122,8 +125,10 @@ module Skylight
 
     # Request ID code based on ActionDispatch::RequestId
     def set_request_id(env)
+      return if env[SKYLIGHT_REQUEST_ID]
+
       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)
+      self.current_request_id = env[SKYLIGHT_REQUEST_ID] = make_request_id(existing_request_id)
     end
 
     def make_request_id(request_id)
@@ -133,5 +138,13 @@ module Skylight
     def internal_request_id
       SecureRandom.uuid
     end
+
+    def current_request_id
+      Thread.current[SKYLIGHT_REQUEST_ID]
+    end
+
+    def current_request_id=(request_id)
+      Thread.current[SKYLIGHT_REQUEST_ID] = request_id
+    end
   end
 end

data/lib/skylight/native.rb

@@ -59,13 +59,13 @@ module Skylight
   end
 
   def self.libskylight_path
-    ENV["SKYLIGHT_LIB_PATH"] || File.expand_path("../native/#{Util::Platform.tuple}", __FILE__)
+    ENV.fetch("SKYLIGHT_LIB_PATH") { File.expand_path("../native/#{Util::Platform.tuple}", __FILE__) }
   end
 
-  skylight_required = ENV.key?("SKYLIGHT_REQUIRED") && ENV["SKYLIGHT_REQUIRED"] !~ /^false$/i
+  skylight_required = ENV.key?("SKYLIGHT_REQUIRED") && ENV.fetch("SKYLIGHT_REQUIRED", nil) !~ /^false$/i
 
   begin
-    unless ENV.key?("SKYLIGHT_DISABLE_AGENT") && ENV["SKYLIGHT_DISABLE_AGENT"] !~ /^false$/i
+    unless ENV.key?("SKYLIGHT_DISABLE_AGENT") && ENV.fetch("SKYLIGHT_DISABLE_AGENT", nil) !~ /^false$/i
       lib = "#{libskylight_path}/libskylight.#{Util::Platform.libext}"
 
       if File.exist?(lib)

data/lib/skylight/normalizers/active_job/perform.rb

@@ -15,7 +15,7 @@ module Skylight
             .tap do |str|
               if str.match(DELIVERY_JOB)
                 mailer_class, mailer_method, * = job_instance.arguments
-                return "#{mailer_class}##{mailer_method}", str
+                return "#{mailer_class}##{mailer_method}", str if mailer_class && mailer_method
               end
             end
         end
@@ -33,9 +33,7 @@ module Skylight
         end
 
         def normalize_after(trace, _span, _name, payload)
-          return unless config.enable_segments? && assign_endpoint?(trace, payload)
-
-          trace.segment = payload[:job].queue_name
+          maybe_set_endpoint(trace, payload)
         end
 
         private
@@ -53,31 +51,30 @@ module Skylight
         end
 
         def maybe_set_endpoint(trace, payload)
-          trace.endpoint = normalize_title(payload[:job]) if assign_endpoint?(trace, payload)
-        end
+          endpoint = normalize_title(payload[:job])
 
-        def assign_endpoint?(trace, payload)
           # Always assign the endpoint if it has not yet been assigned by the ActiveJob probe.
-          return true unless trace.endpoint
-          if defined?(Skylight::Probes::ActiveJob::TITLE) && trace.endpoint == Skylight::Probes::ActiveJob::TITLE
-            return true
-          end
-          if defined?(SKylight::Probes::DelayedJob::Probe::UNKNOWN) &&
-               trace.endpoint == Skylight::Probes::DelayedJob::Probe::UNKNOWN
-            return true
+          if !trace.endpoint ||
+               (defined?(Skylight::Probes::ActiveJob::TITLE) && trace.endpoint == Skylight::Probes::ActiveJob::TITLE) ||
+               (
+                 defined?(Skylight::Probes::DelayedJob::Probe::UNKNOWN) &&
+                   trace.endpoint == Skylight::Probes::DelayedJob::Probe::UNKNOWN
+               ) ||
+               # If a job is called using #perform_now inside a controller action
+               # or within another job's #perform method, we do not want this to
+               # overwrite the existing endpoint name (unless it is the default from ActiveJob).
+               #
+               # If the current endpoint name matches this payload, return true to allow the
+               # segment to be assigned by normalize_after.
+               trace.endpoint =~ DELIVERY_JOB ||
+               # This adapter wrapper needs to be handled specifically due to interactions with the
+               # standalone Delayed::Job probe, as there is no consistent way to get the wrapped
+               # job name among all Delayed::Job backends.
+               trace.endpoint == DELAYED_JOB_WRAPPER
+            trace.endpoint = endpoint
           end
 
-          # If a job is called using #perform_now inside a controller action
-          # or within another job's #perform method, we do not want this to
-          # overwrite the existing endpoint name (unless it is the default from ActiveJob).
-          #
-          # If the current endpoint name matches this payload, return true to allow the
-          # segment to be assigned by normalize_after.
-          trace.endpoint == DELIVERY_JOB || trace.endpoint == normalize_title(payload[:job]) ||
-            # This adapter wrapper needs to be handled specifically due to interactions with the
-            # standalone Delayed::Job probe, as there is no consistent way to get the wrapped
-            # job name among all Delayed::Job backends.
-            trace.endpoint == DELAYED_JOB_WRAPPER
+          trace.segment = payload[:job].queue_name if trace.endpoint == endpoint && config.enable_segments?
         end
 
         def normalize_title(job_instance)

data/lib/skylight/normalizers/active_record/sql.rb

@@ -7,6 +7,14 @@ module Skylight
       class SQL < Skylight::Normalizers::SQL
         register "sql.active_record"
       end
+
+      class FutureResult < Normalizer
+        register "future_result.active_record"
+
+        def normalize(_trace, _name, payload)
+          ["db.future_result", "Async #{payload[:args][1] || "Query"}"]
+        end
+      end
     end
   end
 end

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

@@ -20,7 +20,7 @@ module Skylight
 
         def get_namespace(endpoint)
           # slice off preceding slash for data continuity
-          ::Grape::Namespace.joined_space_path(endpoint.namespace_stackable(:namespace)).to_s[1..-1]
+          ::Grape::Namespace.joined_space_path(endpoint.namespace_stackable(:namespace)).to_s[1..]
         end
       end
     end

data/lib/skylight/normalizers/sql.rb

@@ -14,14 +14,10 @@ module Skylight
       # @option payload [String] [:name] The SQL operation
       # @option payload [Hash] [:binds] The bound parameters
       # @return [Array]
-      def normalize(_trace, name, payload)
-        case payload[:name]
-        when "SCHEMA", "CACHE"
-          return :skip
-        else
-          name = CAT
-          title = payload[:name] || "SQL"
-        end
+      def normalize(_trace, _name, payload)
+        return :skip if payload[:name] == "SCHEMA" || payload[:name] == "CACHE"
+
+        title = payload[:name] || "SQL"
 
         # We can only handle UTF-8 encoded strings.
         # (Construction method here avoids extra allocations)
@@ -38,7 +34,7 @@ module Skylight
           sql = nil
         end
 
-        [name, title, sql]
+        [CAT, title, sql]
       end
     end
   end

data/lib/skylight/probes/active_record_async.rb

@@ -0,0 +1,96 @@
+module Skylight
+  module Probes
+    module ActiveRecord
+      module FutureResult
+        # Applied to ActiveSupport::Notifications::Event
+        module AsyncEventExtensions
+          # Notify Skylight that the event has started
+          def __sk_start!
+            subscriber = Skylight.instrumenter.subscriber
+            subscriber.start(name, nil, payload)
+            trace = Skylight.instrumenter.current_trace
+
+            # Set a finisher to end the event
+            @__sk_finisher = ->(name, payload) do
+              subscriber.with_trace(trace) { subscriber.finish(name, nil, payload) }
+            end
+
+            # End it immediately if we've actually already ended
+            __sk_finish! if @end
+          rescue StandardError => e
+            Skylight.error("Unable to start event for FutureResult: #{e}")
+          end
+
+          # Notify Skylight that the event has finished
+          def __sk_finish!
+            return unless @__sk_finisher
+
+            @__sk_finisher.call(name, payload)
+            @__sk_finisher = nil
+          rescue StandardError => e
+            Skylight.error("Unable to finish event for FutureResult: #{e}")
+          end
+
+          # When the event is marked as finish make sure we notify Skylight
+          def finish!
+            super
+            __sk_finish!
+          end
+        end
+
+        # Applied to FutureResult
+        module Instrumentation
+          def result(*, **)
+            # This instruments the whole FutureResult so that we know when we were executing (potenially) async.
+            ActiveSupport::Notifications.instrument("future_result.active_record", { args: @args, kwargs: @kwargs }) do
+              super
+            end
+          end
+
+          private
+
+          def execute_or_wait(*, **)
+            # At this point we're actually waiting for the query to have finished executing.
+
+            begin
+              # If the query has already started async, the @event_buffer will be defined.
+              # We grab the events (currently only the SQL queries), extend them with our
+              # special methods and notify Skylight.
+              # We act as if the event has just stared, though the query may already have been
+              # running. This means we're essentially just logging blocking time right now.
+
+              # Dup here just in case more get added somehow during the super call
+              events = @event_buffer&.instance_variable_get(:@events).dup
+
+              events&.each do |event|
+                event.singleton_class.prepend(AsyncEventExtensions)
+                event.__sk_start!
+              end
+            rescue StandardError => e
+              Skylight.error("Unable to start events for FutureResult: #{e}")
+            end
+
+            super
+          ensure
+            # Once we've actually got a result, we mark each one as finished.
+            # Note that it may have already finished, but if it didn't we need to say so now.
+            events&.reverse_each(&:__sk_finish!)
+          end
+        end
+
+        class Probe
+          def install
+            ::ActiveRecord::FutureResult.prepend(Instrumentation)
+          end
+        end
+      end
+    end
+
+    register(
+      :active_record_async,
+      "ActiveRecord::FutureResult",
+      "active_record/future_result",
+      ActiveRecord::FutureResult::Probe.new
+    )
+  end
+end

data/lib/skylight/probes/elasticsearch.rb

@@ -3,8 +3,17 @@ module Skylight
     module Elasticsearch
       class Probe
         def install
+          const =
+            if defined?(::Elasticsearch::Transport::Transport::Base)
+              ::Elasticsearch::Transport::Transport::Base
+            elsif defined?(::Elastic::Transport::Transport::Base)
+              ::Elastic::Transport::Transport::Base
+            else
+              return false
+            end
+
           # Prepending doesn't work here since this a module that's already been included
-          ::Elasticsearch::Transport::Transport::Base.class_eval do
+          const.class_eval do
             alias_method :perform_request_without_sk, :perform_request
             def perform_request(method, path, *args, &block)
               ActiveSupport::Notifications.instrument(

data/lib/skylight/probes/middleware.rb

@@ -25,10 +25,10 @@ module Skylight
       # for Rails <= 5.2 ActionDispatch::MiddlewareStack::Middleware
       module Instrumentation
         def build(*)
-          sk_instrument_middleware(super)
+          Instrumentation.sk_instrument_middleware(super)
         end
 
-        def sk_instrument_middleware(middleware)
+        def self.sk_instrument_middleware(middleware)
           return middleware if middleware.is_a?(Skylight::Middleware)
 
           # Not sure how this would actually happen

data/lib/skylight/probes/mongo.rb

@@ -5,7 +5,20 @@ module Skylight
 
       class Probe
         def install
-          ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, Subscriber.new)
+          subscriber = Subscriber.new
+
+          # From the mongo driver:
+          #
+          # > Global subscriptions must be established prior to creating
+          # > clients. When a client is constructed it copies subscribers from
+          # > the Global module; subsequent subscriptions or unsubscriptions
+          # > on the Global module have no effect on already created clients.
+          #
+          # So, for existing clients created before the Skylight initializer
+          # runs, we'll have to subscribe to those individually.
+          ::Mongoid::Clients.clients.each { |_name, client| client.subscribe(::Mongo::Monitoring::COMMAND, subscriber) }
+
+          ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, subscriber)
         end
       end
 

data/lib/skylight/probes/mongoid.rb

@@ -1,13 +1,6 @@
-module Skylight
-  module Probes
-    module Mongoid
-      class Probe
-        def install
-          Skylight::Probes.probe(:mongo)
-        end
-      end
-    end
-
-    register(:mongoid, "Mongoid", "mongoid", Mongoid::Probe.new)
-  end
-end
+# Older versions of the mongoid uses the moped under-the-hood, while newer
+# verions uses the official driver. It used to be that the the mongoid probe
+# exists to detect and enable either one of those underlying probes, but at
+# this point we no longer support moped, so this is now just an alias for the
+# mongo probe.
+require_relative "mongo"

data/lib/skylight/probes/rack_builder.rb

@@ -0,0 +1,37 @@
+module Skylight
+  module Probes
+    module Rack
+      module Builder
+        module Instrumentation
+          def use(middleware, *args, &block)
+            if @map
+              mapping = @map
+              @map = nil
+              @use << proc { |app| generate_map(app, mapping) }
+            end
+            @use << proc do |app|
+              middleware
+                .new(app, *args, &block)
+                .tap do |middleware_instance|
+                  Skylight::Probes::Middleware::Instrumentation.sk_instrument_middleware(middleware_instance)
+                end
+            end
+          end
+          ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+        end
+
+        class Probe
+          def install
+            if defined?(::Rack.release) && Gem::Version.new(::Rack.release) >= ::Gem::Version.new("1.4") &&
+                 defined?(::Rack::Builder)
+              require "skylight/probes/middleware"
+              ::Rack::Builder.prepend(Instrumentation)
+            end
+          end
+        end
+      end
+    end
+
+    register(:rack_builder, "Rack::Builder", "rack/builder", Skylight::Probes::Rack::Builder::Probe.new)
+  end
+end

data/lib/skylight/probes/sinatra_add_middleware.rb

@@ -2,8 +2,8 @@ module Skylight
   module Probes
     module Sinatra
       module Instrumentation
-        def build(*)
-          use Skylight::Middleware
+        def setup_default_middleware(builder)
+          builder.use Skylight::Middleware
           super
         end
       end

data/lib/skylight/probes.rb

@@ -78,15 +78,14 @@ module Skylight
       end
 
       def add_path(path)
-        root = Pathname.new(path)
-        Pathname
-          .glob(root.join("./**/*.rb"))
-          .each do |f|
-            name = f.relative_path_from(root).sub_ext("").to_s
-            raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{f}" if available.key?(name)
-
-            available[name] = f
-          end
+        Dir.glob("**/*.rb", base: path) do |f|
+          name = Pathname.new(f).sub_ext("").to_s
+          full_path = File.expand_path(f, path)
+
+          raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{full_path}" if available.key?(name)
+
+          available[name] = full_path
+        end
       end
 
       def available

data/lib/skylight/railtie.rb

@@ -16,7 +16,15 @@ module Skylight
     #   net_http, action_controller, action_dispatch, action_view, and middleware are on by default
     #   See https://www.skylight.io/support/getting-more-from-skylight#available-instrumentation-options
     #   for a full list.
-    config.skylight.probes = %w[net_http action_controller action_dispatch action_view middleware active_job_enqueue]
+    config.skylight.probes = %w[
+      net_http
+      action_controller
+      action_dispatch
+      action_view
+      middleware
+      active_job_enqueue
+      active_record_async
+    ]
 
     # The position in the middleware stack to place Skylight
     # Default is first, but can be `{ after: Middleware::Name }` or `{ before: Middleware::Name }`
@@ -99,8 +107,8 @@ module Skylight
 
       configure_logging(config, app)
 
-      config[:'daemon.sockdir_path'] ||= tmp
-      config[:'normalizers.render.view_paths'] = existent_paths(app.config.paths["app/views"]) + [Rails.root.to_s]
+      config[:"daemon.sockdir_path"] ||= tmp
+      config[:"normalizers.render.view_paths"] = existent_paths(app.config.paths["app/views"]) + [Rails.root.to_s]
 
       config[:env] ||= Rails.env.to_s if config[:report_rails_env]
 
@@ -145,7 +153,7 @@ module Skylight
       return false unless sk_config
 
       key = "SKYLIGHT_ENABLED"
-      activate = ENV.key?(key) ? ENV[key] !~ /^false$/i : environments.include?(Rails.env.to_s)
+      activate = ENV.key?(key) ? ENV.fetch(key, nil) !~ /^false$/i : environments.include?(Rails.env.to_s)
 
       show_worker_activation_warning(sk_config) if activate
 

data/lib/skylight/sidekiq.rb

@@ -21,7 +21,7 @@ module Skylight
 
       def call(worker, job, queue)
         t { "Sidekiq middleware beginning trace" }
-        title = job["wrapped"] || job["class"]
+        title = job["display_class"] || job["wrapped"] || job["class"]
 
         # TODO: Using hints here would be ideal but requires further refactoring
         meta =

data/lib/skylight/sinatra.rb

@@ -1,2 +1,2 @@
 require "skylight"
-Skylight.probe(:sinatra_add_middleware, :sinatra, :tilt, :sequel)
+Skylight.probe(:sinatra_add_middleware, :sinatra, :tilt, :sequel, :rack_builder)

data/lib/skylight/subscriber.rb

@@ -36,16 +36,30 @@ module Skylight
       end
     end
 
+    # cargo-culted from Rails's ConnectionAdapter
+    EXCEPTION_NEVER = { Exception => :never }.freeze # :nodoc:
+    EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze # :nodoc:
+    private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
+    def with_trace(trace, &block) # :nodoc:
+      Thread.handle_interrupt(EXCEPTION_NEVER) do
+        previous_trace = @trace
+        @trace = trace
+        Thread.handle_interrupt(EXCEPTION_IMMEDIATE, &block)
+      ensure
+        @trace = previous_trace
+      end
+    end
+
     def start(name, _id, payload)
       return if @instrumenter.disabled?
-      return unless (trace = @instrumenter.current_trace)
+      return unless (trace = current_trace)
 
       _start(trace, name, payload)
     end
 
     def finish(name, _id, payload)
       return if @instrumenter.disabled?
-      return unless (trace = @instrumenter.current_trace)
+      return unless (trace = current_trace)
 
       while (curr = trace.notifications.pop)
         next unless curr.name == name
@@ -70,8 +84,16 @@ module Skylight
       # Ignored for now because nothing in rails uses it
     end
 
+    def publish_event(event)
+      # Ignored for now because only ActiveRecord::FutureResult uses it and we handle that with probes
+    end
+
     private
 
+    def current_trace
+      @trace || @instrumenter.current_trace
+    end
+
     def normalize(*args)
       @normalizers.normalize(*args)
     end

data/lib/skylight/test.rb

@@ -25,10 +25,6 @@ module Skylight
                   "Mocked Instrumenter"
                 end
 
-                def self.native_new(*)
-                  allocate
-                end
-
                 def native_start
                   true
                 end
@@ -47,7 +43,7 @@ module Skylight
               :Trace,
               Class.new(OriginalTrace) do
                 def self.native_new(start, _uuid, endpoint, meta)
-                  inst = allocate
+                  inst = super
                   inst.instance_variable_set(:@start, start)
                   inst.instance_variable_set(:@endpoint, endpoint)
                   inst.instance_variable_set(:@starting_endpoint, endpoint)

data/lib/skylight/user_config.rb

@@ -18,7 +18,9 @@ module Skylight
         @config[:user_config_path] ||
           begin
             require "etc"
-            home_dir = ENV["HOME"] || Etc.getpwuid.dir || (ENV["USER"] && File.expand_path("~#{ENV["USER"]}"))
+            home_dir =
+              ENV.fetch("HOME", nil) || Etc.getpwuid.dir ||
+                (ENV.fetch("USER", nil) && File.expand_path("~#{ENV.fetch("USER", nil)}"))
             if home_dir
               File.join(home_dir, ".skylight")
             else
@@ -31,7 +33,7 @@ module Skylight
     end
 
     def disable_dev_warning?
-      disable_dev_warning || ENV["SKYLIGHT_DISABLE_DEV_WARNING"] =~ /^true$/i
+      disable_dev_warning || ENV.fetch("SKYLIGHT_DISABLE_DEV_WARNING", nil) =~ /^true$/i
     end
 
     def disable_env_warning?

data/lib/skylight/util/clock.rb

@@ -13,7 +13,7 @@ module Skylight
       # rubocop:disable Lint/DuplicateMethods
       def tick
         now = Time.now
-        now.to_i * 1_000_000_000 + now.usec * 1_000
+        (now.to_i * 1_000_000_000) + (now.usec * 1_000)
       end
 
       # rubocop:enable Lint/DuplicateMethods