skylight 5.0.0.beta → 5.0.0

data/lib/skylight/probes/active_job_enqueue.rb

@@ -6,21 +6,25 @@ module Skylight
 
         def install
           ::ActiveJob::Base.around_enqueue do |job, block|
-            begin
-              job_class = job.class
-              adapter_name = EnqueueProbe.normalize_adapter_name(job_class)
+            job_class = job.class
+            adapter_name = EnqueueProbe.normalize_adapter_name(job_class)
 
-              # If this is an ActionMailer::DeliveryJob, we'll report this as the mailer title
-              # and include ActionMailer::DeliveryJob in the description.
-              name, job_class_name = Normalizers::ActiveJob::Perform.normalize_title(job)
-              descriptors = ["adapter: '#{adapter_name}'", "queue: '#{job.queue_name}'"]
-              descriptors << "job: '#{job_class_name}'" if job_class_name
-              desc = "{ #{descriptors.join(', ')} }"
-            rescue
-              block.call
-            else
-              Skylight.instrument(title: "Enqueue #{name}", category: CAT, description: desc, &block)
-            end
+            # If this is an ActionMailer::DeliveryJob, we'll report this as the mailer title
+            # and include ActionMailer::DeliveryJob in the description.
+            name, job_class_name = Normalizers::ActiveJob::Perform.normalize_title(job)
+            descriptors = ["adapter: '#{adapter_name}'", "queue: '#{job.queue_name}'"]
+            descriptors << "job: '#{job_class_name}'" if job_class_name
+            desc = "{ #{descriptors.join(', ')} }"
+          rescue
+            block.call
+          else
+            Skylight.instrument(
+              title:       "Enqueue #{name}",
+              category:    CAT,
+              description: desc,
+              internal:    true,
+              &block
+            )
           end
 
           self.class.instance_eval do

data/lib/skylight/probes/active_model_serializers.rb

@@ -14,12 +14,8 @@ module Skylight
 
           # File moved location between version
           %w[serializer serializers].each do |dir|
-            # rubocop:disable Lint/SuppressedException
-            begin
-              require "active_model/#{dir}/version"
-            rescue LoadError
-            end
-            # rubocop:enable Lint/SuppressedException
+            require "active_model/#{dir}/version"
+          rescue LoadError # rubocop:disable Lint/SuppressedException
           end
 
           if Gem.loaded_specs["active_model_serializers"]

data/lib/skylight/probes/delayed_job.rb

@@ -1,46 +1,133 @@
+# frozen_string_literal: true
+
+require "delegate"
+
 module Skylight
   module Probes
     module DelayedJob
-      module Instrumentation
-        include Skylight::Util::Logging
-
-        def run(job, *)
-          t { "Delayed::Job beginning trace" }
-
-          handler_name =
-            begin
-              if defined?(::Delayed::PerformableMethod) && job.payload_object.is_a?(::Delayed::PerformableMethod)
-                job.name
-              else
-                job.payload_object.class.name
-              end
-            rescue
-              UNKNOWN
+      begin
+        require "delayed/plugin"
+
+        class Plugin < ::Delayed::Plugin
+          callbacks do |lifecycle|
+            lifecycle.around(:perform) do |worker, job, &block|
+              sk_instrument(worker, job, &block)
             end
 
-          Skylight.trace(handler_name, "app.delayed_job.worker", "Delayed::Worker#run",
-                         component: :worker, segment: job.queue) { super }
+            lifecycle.after(:error) do |_worker, _job|
+              Skylight.trace&.segment = "error"
+            end
+          end
+
+          class << self
+            include Skylight::Util::Logging
+
+            def sk_instrument(_worker, job)
+              endpoint = Skylight::Probes::DelayedJob.handler_name(job)
+
+              Skylight.trace(endpoint,
+                             "app.delayed_job.worker",
+                             "Delayed::Worker#run",
+                             component: :worker,
+                             segment:   job.queue,
+                             meta:      { source_location: "delayed_job" }) do
+                               t { "Delayed::Job beginning trace" }
+                               yield
+                             end
+            end
+          end
         end
+      rescue LoadError
+        $stderr.puts "[SKYLIGHT] The delayed_job probe was requested, but Delayed::Plugin was not defined."
+      end
+
+      UNKNOWN = "<Delayed::Job Unknown>"
 
-        def handle_failed_job(*)
-          super
-          return unless Skylight.trace
+      def self.handler_name(job)
+        payload_object = if job.respond_to?(:payload_object_without_sk)
+                           job.payload_object_without_sk
+                         else
+                           job.payload_object
+                         end
+
+        payload_object_name(payload_object)
+      end
 
-          Skylight.trace.segment = "error"
+      def self.payload_object_name(payload_object)
+        if payload_object.is_a?(::Delayed::PerformableMethod)
+          payload_object.display_name
+        else
+          # In the case of ActiveJob-wrapped jobs, there is quite a bit of job-specific metadata
+          # in `job.name`, which would break aggregation and potentially leak private data in job args.
+          # Use class name instead to avoid this.
+          payload_object.class.name
         end
+      rescue
+        UNKNOWN
       end
 
-      class Probe
-        UNKNOWN = "<Delayed::Job Unknown>".freeze
+      def self.payload_object_source_meta(payload_object)
+        if payload_object.is_a?(::Delayed::PerformableMethod)
+          if payload_object.object.is_a?(Module)
+            [:class_method, payload_object.object.name, payload_object.method_name.to_s]
+          else
+            [:instance_method, payload_object.object.class.name, payload_object.method_name.to_s]
+          end
+        else
+          [:instance_method, payload_object.class.name, "perform"]
+        end
+      end
 
+      class InstrumentationProxy < SimpleDelegator
+        def perform
+          source_meta = Skylight::Probes::DelayedJob.payload_object_source_meta(__getobj__)
+
+          opts = {
+            category: "app.delayed_job.job",
+            title:    format_source(*source_meta),
+            meta:     { source_location_hint: source_meta },
+            internal: true
+          }
+
+          Skylight.instrument(opts) { __getobj__.perform }
+        end
+
+        # Used by Delayed::Backend::Base to determine Job#name
+        def display_name
+          __getobj__.respond_to?(:display_name) ? __getobj__.display_name : __getobj__.class.name
+        end
+
+        private
+
+          def format_source(method_type, constant_name, method_name)
+            if method_type == :instance_method
+              "#{constant_name}##{method_name}"
+            else
+              "#{constant_name}.#{method_name}"
+            end
+          end
+      end
+
+      class Probe
         def install
-          return unless validate_version
+          return unless validate_version && plugin_defined?
+
+          ::Delayed::Worker.plugins = [Skylight::Probes::DelayedJob::Plugin] | ::Delayed::Worker.plugins
+          ::Delayed::Backend::Base.class_eval do
+            alias_method :payload_object_without_sk, :payload_object
 
-          ::Delayed::Worker.prepend(Instrumentation)
+            def payload_object
+              Skylight::Probes::DelayedJob::InstrumentationProxy.new(payload_object_without_sk)
+            end
+          end
         end
 
         private
 
+          def plugin_defined?
+            defined?(::Skylight::Probes::DelayedJob::Plugin)
+          end
+
           def validate_version
             spec = Gem.loaded_specs["delayed_job"]
             version = spec&.version

data/lib/skylight/probes/elasticsearch.rb

@@ -26,7 +26,7 @@ module Skylight
 
             def disable_skylight_probe(class_name)
               klass = ::ActiveSupport::Inflector.safe_constantize("Skylight::Probes::#{class_name}::Probe")
-              (klass ? klass.disable { yield } : yield).tap { puts "re-enabling: #{klass}" }
+              (klass ? klass.disable { yield } : yield).tap { Skylight.log(:debug, "re-enabling: #{klass}") }
             end
           end
         end

data/lib/skylight/probes/excon/middleware.rb

@@ -6,7 +6,7 @@ module Skylight
       # Middleware for Excon that instruments requests
       class Middleware < ::Excon::Middleware::Base
         def initialize(*)
-          @requests = {}
+          @requests = {}.compare_by_identity
           super
         end
 
@@ -38,19 +38,19 @@ module Skylight
             scheme = datum[:scheme]
             host   = datum[:host]
             # TODO: Maybe don't show other default ports like 443
-            port   = datum[:port] != 80 ? datum[:port] : nil
+            port   = datum[:port] == 80 ? nil : datum[:port]
             path   = datum[:path]
             query  = datum[:query]
 
             opts = Formatters::HTTP.build_opts(method, scheme, host, port, path, query)
 
-            @requests[datum.object_id] = Skylight.instrument(opts)
+            @requests[datum] = Skylight.instrument(opts)
           rescue Exception => e
             Skylight.error "failed to begin instrumentation for Excon; msg=%s", e.message
           end
 
           def end_instrumentation(datum)
-            if (request = @requests.delete(datum.object_id))
+            if (request = @requests.delete(datum))
               meta = {}
               if datum[:error].is_a?(Exception)
                 meta[:exception_object] = datum[:error]

data/lib/skylight/probes/middleware.rb

@@ -72,7 +72,8 @@ module Skylight
 
               source_file, source_line = method(__method__).super_method.source_location
 
-              spans = Skylight.instrument(title: name, category: __sk_category, source_file: source_file, source_line: source_line)
+              spans = Skylight.instrument(title: name, category: __sk_category,
+                                          source_file: source_file, source_line: source_line)
 
               proxied_response =
                 Skylight::Middleware.with_after_close(super(*args), debug_identifier: "Middleware: #{name}") do

data/lib/skylight/probes/mongo.rb

@@ -113,7 +113,8 @@ module Skylight
               category:    CAT,
               title:       title,
               description: payload.empty? ? nil : payload.to_json,
-              meta:        { database: event.database_name }
+              meta:        { database: event.database_name },
+              internal:    true
             }
 
             @events[event.operation_id] = Skylight.instrument(opts)

data/lib/skylight/probes/net_http.rb

@@ -14,7 +14,6 @@ module Skylight
 
           # If we're connected with a persistent socket
           host ||= address
-          port ||= port
 
           path   = req.path
           scheme = use_ssl? ? "https" : "http"

data/lib/skylight/probes/redis.rb

@@ -6,12 +6,14 @@ module Skylight
 
       PIPELINED_OPTS = {
         category: "db.redis.pipelined".freeze,
-        title:    "PIPELINE".freeze
+        title:    "PIPELINE".freeze,
+        internal: true
       }.freeze
 
       MULTI_OPTS = {
         category: "db.redis.multi".freeze,
-        title:    "MULTI".freeze
+        title:    "MULTI".freeze,
+        internal: true
       }.freeze
 
       module ClientInstrumentation
@@ -22,7 +24,8 @@ module Skylight
 
           opts = {
             category: "db.redis.command",
-            title:    command_name.upcase.to_s
+            title:    command_name.upcase.to_s,
+            internal: true
           }
 
           Skylight.instrument(opts) { super }

data/lib/skylight/railtie.rb

@@ -99,7 +99,7 @@ module Skylight
           return nil
         end
 
-        config = Config.load(file: path, environment: Rails.env.to_s)
+        config = Config.load(file: path, priority_key: Rails.env.to_s)
         config[:root] = Rails.root
 
         configure_logging(config, app)

data/lib/skylight/sidekiq.rb

@@ -19,16 +19,21 @@ module Skylight
     class ServerMiddleware
       include Util::Logging
 
-      def call(_worker, job, queue)
+      def call(worker, job, queue)
         t { "Sidekiq middleware beginning trace" }
         title = job["wrapped"] || job["class"]
-        Skylight.trace(title, "app.sidekiq.worker", title, segment: queue, component: :worker) do |trace|
-          begin
-            yield
-          rescue Exception # includes Sidekiq::Shutdown
-            trace.segment = "error" if trace
-            raise
+
+        # TODO: Using hints here would be ideal but requires further refactoring
+        meta =
+          if (source_location = worker.method(:perform).source_location)
+            { source_file: source_location[0], source_line: source_location[1] }
           end
+
+        Skylight.trace(title, "app.sidekiq.worker", title, meta: meta, segment: queue, component: :worker) do |trace|
+          yield
+        rescue Exception # includes Sidekiq::Shutdown
+          trace.segment = "error" if trace
+          raise
         end
       end
     end

data/lib/skylight/subscriber.rb

@@ -14,7 +14,7 @@ module Skylight
 
     def register!
       unregister!
-      @normalizers.keys.each do |key|
+      @normalizers.keys.each do |key| # rubocop:disable Style/HashEachMethods
         @subscribers << ActiveSupport::Notifications.subscribe(key, self)
       end
     end

data/lib/skylight/trace.rb

@@ -4,8 +4,9 @@ require "skylight/util/logging"
 module Skylight
   class Trace
     GC_CAT = "noise.gc".freeze
+    SYNTHETIC = "<synthetic>".freeze
 
-    META_KEYS = %i[mute_children].freeze
+    META_KEYS = %i[mute_children database].freeze
 
     include Util::Logging
 
@@ -39,6 +40,8 @@ module Skylight
 
       @spans = []
 
+      preprocess_meta(meta) if meta
+
       # create the root node
       @root = start(native_get_started_at, cat, title, desc, meta, normalize: false)
 
@@ -217,7 +220,8 @@ module Skylight
 
         if time > 0
           t { fmt "tracking GC time; duration=%d", time }
-          stop(start(now - time, GC_CAT, nil, nil, nil), now)
+          meta = { source_location: SYNTHETIC }
+          stop(start(now - time, GC_CAT, nil, nil, meta), now)
         end
       end
 
@@ -336,8 +340,10 @@ module Skylight
       def validate_meta(meta)
         unknown_keys = meta.keys - allowed_meta_keys
         if unknown_keys.any?
-          warn "Unknown meta keys will be ignored; keys=#{unknown_keys.inspect}"
-          unknown_keys.each { |key| meta.delete(key) }
+          unknown_keys.each do |key|
+            maybe_warn("unknown_meta:#{key}", "Unknown meta key will be ignored; key=#{key.inspect}")
+            meta.delete(key)
+          end
         end
       end
 

data/lib/skylight/util/deploy.rb

@@ -13,8 +13,7 @@ module Skylight
       end
 
       class EmptyDeploy
-        attr_reader :config
-        attr_reader :timestamp
+        attr_reader :config, :timestamp
 
         def initialize(config)
           @config = config
@@ -90,10 +89,8 @@ module Skylight
           def get_info
             info_path = config[:'heroku.dyno_info_path']
 
-            if File.exist?(info_path)
-              if (info = JSON.parse(File.read(info_path)))
-                info["release"]
-              end
+            if File.exist?(info_path) && (info = JSON.parse(File.read(info_path)))
+              info["release"]
             end
           end
       end

data/lib/skylight/util/instrumenter_method.rb

@@ -4,20 +4,20 @@ module Skylight
       def instrumenter_method(name, block: false)
         if block
           module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}(*args)
-              unless instrumenter
-                return yield if block_given?
-                return
-              end
-
-              instrumenter.#{name}(*args) { yield }
-            end
+            def #{name}(*args)                      # def mute(*args)
+              unless instrumenter                   #   unless instrumenter
+                return yield if block_given?        #     return yield if block_given?
+                return                              #     return
+              end                                   #   end
+                                                    #
+              instrumenter.#{name}(*args) { yield } #   instrumenter.mute(*args) { yield }
+            end                                     # end
           RUBY
         else
           module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}(*args)
-              instrumenter&.#{name}(*args)
-            end
+            def #{name}(*args)              # def config(*args)
+              instrumenter&.#{name}(*args)  #   instrumenter&.config(*args)
+            end                             # end
           RUBY
         end
       end