skylight 5.0.0.beta4 → 5.1.0.beta2

data/lib/skylight/probes/middleware.rb

@@ -16,7 +16,7 @@ module Skylight
               elsif middleware.respond_to?(:call)
                 middleware.method(:call).source_location
               end
-            rescue
+            rescue StandardError
               nil
             end
         end
@@ -72,8 +72,13 @@ 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
@@ -120,7 +125,11 @@ module Skylight
       end
     end
 
-    register(:middleware, "ActionDispatch::MiddlewareStack::Middleware", "actionpack/action_dispatch",
-             Middleware::Probe.new)
+    register(
+      :middleware,
+      "ActionDispatch::MiddlewareStack::Middleware",
+      "actionpack/action_dispatch",
+      Middleware::Probe.new
+    )
   end
 end

data/lib/skylight/probes/mongo.rb

@@ -14,9 +14,7 @@ module Skylight
 
         COMMANDS = %i[insert find count distinct update findandmodify findAndModify delete aggregate].freeze
 
-        COMMAND_NAMES = {
-          findandmodify: "findAndModify".freeze
-        }.freeze
+        COMMAND_NAMES = { findandmodify: "findAndModify".freeze }.freeze
 
         def initialize
           @events = {}
@@ -41,121 +39,115 @@ module Skylight
 
         private
 
-          def begin_instrumentation(event)
-            return unless COMMANDS.include?(event.command_name.to_sym)
+        def begin_instrumentation(event)
+          return unless COMMANDS.include?(event.command_name.to_sym)
 
-            command_name = COMMAND_NAMES[event.command_name] || event.command_name.to_s
+          command_name = COMMAND_NAMES[event.command_name] || event.command_name.to_s
 
-            title = "#{event.database_name}.#{command_name}"
+          title = "#{event.database_name}.#{command_name}"
 
-            command = event.command
+          command = event.command
 
-            # Not sure if this will always exist
-            # Delete so the description will be less redundant
-            if (target = command[event.command_name])
-              title << " #{target}"
-            end
-
-            payload = {}
-
-            # Ruby Hashes are ordered based on insertion so do the most important ones first
+          # Not sure if this will always exist
+          # Delete so the description will be less redundant
+          if (target = command[event.command_name])
+            title << " #{target}"
+          end
 
-            add_value("key".freeze, command, payload)
-            add_bound("query".freeze, command, payload)
-            add_bound("filter".freeze, command, payload)
-            add_value("sort".freeze, command, payload)
+          payload = {}
 
-            if command_name == "findAndModify".freeze
-              add_bound("update".freeze, command, payload)
-            end
+          # Ruby Hashes are ordered based on insertion so do the most important ones first
 
-            add_value("remove".freeze, command, payload)
-            add_value("new".freeze, command, payload)
+          add_value("key".freeze, command, payload)
+          add_bound("query".freeze, command, payload)
+          add_bound("filter".freeze, command, payload)
+          add_value("sort".freeze, command, payload)
 
-            if (updates = command["updates".freeze])
-              # AFAICT the gem generally just sends one item in the updates array
-              update = updates[0]
-              update_payload = {}
-              add_bound("q".freeze, update, update_payload)
-              add_bound("u".freeze, update, update_payload)
-              add_value("multi".freeze, update, update_payload)
-              add_value("upsert".freeze, update, update_payload)
+          add_bound("update".freeze, command, payload) if command_name == "findAndModify".freeze
 
-              payload["updates".freeze] = [update_payload]
+          add_value("remove".freeze, command, payload)
+          add_value("new".freeze, command, payload)
 
-              if updates.length > 1
-                payload["updates".freeze] << "..."
-              end
-            end
+          if (updates = command["updates".freeze])
+            # AFAICT the gem generally just sends one item in the updates array
+            update = updates[0]
+            update_payload = {}
+            add_bound("q".freeze, update, update_payload)
+            add_bound("u".freeze, update, update_payload)
+            add_value("multi".freeze, update, update_payload)
+            add_value("upsert".freeze, update, update_payload)
 
-            if (deletes = command["deletes".freeze])
-              # AFAICT the gem generally just sends one item in the updates array
-              delete = deletes[0]
-              delete_payload = {}
-              add_bound("q".freeze, delete, delete_payload)
-              add_value("limit".freeze, delete, delete_payload)
+            payload["updates".freeze] = [update_payload]
 
-              payload["deletes".freeze] = [delete_payload]
+            payload["updates".freeze] << "..." if updates.length > 1
+          end
 
-              if deletes.length > 1
-                payload["deletes".freeze] << "..."
-              end
-            end
+          if (deletes = command["deletes".freeze])
+            # AFAICT the gem generally just sends one item in the updates array
+            delete = deletes[0]
+            delete_payload = {}
+            add_bound("q".freeze, delete, delete_payload)
+            add_value("limit".freeze, delete, delete_payload)
 
-            if (pipeline = command["pipeline".freeze])
-              payload["pipeline".freeze] = pipeline.map { |segment| extract_binds(segment) }
-            end
+            payload["deletes".freeze] = [delete_payload]
 
-            # We're ignoring documents from insert because they could have completely inconsistent
-            # format which would make it hard to merge.
-
-            opts = {
-              category:    CAT,
-              title:       title,
-              description: payload.empty? ? nil : payload.to_json,
-              meta:        { database: event.database_name },
-              internal:    true
-            }
+            payload["deletes".freeze] << "..." if deletes.length > 1
+          end
 
-            @events[event.operation_id] = Skylight.instrument(opts)
-          rescue Exception => e
-            error "failed to begin instrumentation for Mongo; msg=%s", e.message
+          if (pipeline = command["pipeline".freeze])
+            payload["pipeline".freeze] = pipeline.map { |segment| extract_binds(segment) }
           end
 
-          def end_instrumentation(event)
-            if (original_event = @events.delete(event.operation_id))
-              meta = {}
-              if event.is_a?(::Mongo::Monitoring::Event::CommandFailed)
-                meta[:exception] = ["CommandFailed", event.message]
-              end
-              Skylight.done(original_event, meta)
+          # We're ignoring documents from insert because they could have completely inconsistent
+          # format which would make it hard to merge.
+
+          opts = {
+            category: CAT,
+            title: title,
+            description: payload.empty? ? nil : payload.to_json,
+            meta: {
+              database: event.database_name
+            },
+            internal: true
+          }
+
+          @events[event.operation_id] = Skylight.instrument(opts)
+        rescue Exception => e
+          error "failed to begin instrumentation for Mongo; msg=%s", e.message
+        end
+
+        def end_instrumentation(event)
+          if (original_event = @events.delete(event.operation_id))
+            meta = {}
+            if event.is_a?(::Mongo::Monitoring::Event::CommandFailed)
+              meta[:exception] = ["CommandFailed", event.message]
             end
-          rescue Exception => e
-            error "failed to end instrumentation for Mongo; msg=%s", e.message
+            Skylight.done(original_event, meta)
           end
+        rescue Exception => e
+          error "failed to end instrumentation for Mongo; msg=%s", e.message
+        end
 
-          def add_value(key, command, payload)
-            if command.key?(key)
-              value = command[key]
-              payload[key] = value
-            end
+        def add_value(key, command, payload)
+          if command.key?(key)
+            value = command[key]
+            payload[key] = value
           end
+        end
 
-          def add_bound(key, command, payload)
-            if (value = command[key])
-              payload[key] = extract_binds(value)
-            end
+        def add_bound(key, command, payload)
+          if (value = command[key])
+            payload[key] = extract_binds(value)
           end
+        end
 
-          def extract_binds(hash)
-            ret = {}
+        def extract_binds(hash)
+          ret = {}
 
-            hash.each do |k, v|
-              ret[k] = v.is_a?(Hash) ? extract_binds(v) : "?".freeze
-            end
+          hash.each { |k, v| ret[k] = v.is_a?(Hash) ? extract_binds(v) : "?".freeze }
 
-            ret
-          end
+          ret
+        end
       end
     end
 

data/lib/skylight/probes/net_http.rb

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

data/lib/skylight/probes/redis.rb

@@ -4,17 +4,9 @@ module Skylight
       # Unfortunately, because of the nature of pipelining, there's no way for us to
       # give a time breakdown on the individual items.
 
-      PIPELINED_OPTS = {
-        category: "db.redis.pipelined".freeze,
-        title:    "PIPELINE".freeze,
-        internal: true
-      }.freeze
-
-      MULTI_OPTS = {
-        category: "db.redis.multi".freeze,
-        title:    "MULTI".freeze,
-        internal: true
-      }.freeze
+      PIPELINED_OPTS = { category: "db.redis.pipelined".freeze, title: "PIPELINE".freeze, internal: true }.freeze
+
+      MULTI_OPTS = { category: "db.redis.multi".freeze, title: "MULTI".freeze, internal: true }.freeze
 
       module ClientInstrumentation
         def call(command, *)
@@ -22,11 +14,7 @@ module Skylight
 
           return super if command_name == :auth
 
-          opts = {
-            category: "db.redis.command",
-            title:    command_name.upcase.to_s,
-            internal: true
-          }
+          opts = { category: "db.redis.command", title: command_name.upcase.to_s, internal: true }
 
           Skylight.instrument(opts) { super }
         end
@@ -48,7 +36,7 @@ module Skylight
 
           if !version || version < Gem::Version.new("3.0.0")
             Skylight.error "The installed version of Redis doesn't support Middlewares. " \
-                           "At least version 3.0.0 is required."
+                             "At least version 3.0.0 is required."
             return
           end
 

data/lib/skylight/probes/sequel.rb

@@ -8,20 +8,16 @@ module Skylight
 
           method_name = ::Sequel::Database.method_defined?(:log_connection_yield) ? "log_connection_yield" : "log_yield"
 
-          mod = Module.new do
-            define_method method_name do |sql, *args, &block|
-              super(sql, *args) do
-                ::ActiveSupport::Notifications.instrument(
-                  "sql.sequel",
-                  sql:   sql,
-                  name:  "SQL",
-                  binds: args
-                ) do
-                  block.call
+          mod =
+            Module.new do
+              define_method method_name do |sql, *args, &block|
+                super(sql, *args) do
+                  ::ActiveSupport::Notifications.instrument("sql.sequel", sql: sql, name: "SQL", binds: args) do
+                    block.call
+                  end
                 end
               end
             end
-          end
 
           ::Sequel::Database.prepend(mod)
         end

data/lib/skylight/probes/sinatra.rb

@@ -37,11 +37,14 @@ module Skylight
         end
 
         def compile_template(engine, data, options, *)
-          # Pass along a useful "virtual path" to Tilt. The Tilt probe will handle
-          # instrumenting correctly.
-          options[:sky_virtual_path] = data.is_a?(Symbol) ? data.to_s : "Inline template (#{engine})"
-
-          super
+          super.tap do |template|
+            if defined?(::Tilt::Template) && template.is_a?(::Tilt::Template)
+              # Pass along a useful "virtual path" to Tilt. The Tilt probe will handle
+              # instrumenting correctly.
+              virtual_path = data.is_a?(Symbol) ? data.to_s : "Inline template (#{engine})"
+              template.instance_variable_set(:@__sky_virtual_path, virtual_path)
+            end
+          end
         end
       end
 

data/lib/skylight/probes/tilt.rb

@@ -6,12 +6,10 @@ module Skylight
         def render(*args, &block)
           opts = {
             category: "view.render.template",
-            title:    options[:sky_virtual_path] || basename || "Unknown template name"
+            title: @__sky_virtual_path || options[:sky_virtual_path] || basename || "Unknown template name"
           }
 
-          Skylight.instrument(opts) do
-            super(*args, &block)
-          end
+          Skylight.instrument(opts) { super(*args, &block) }
         end
       end
 

data/lib/skylight/railtie.rb

@@ -28,183 +28,169 @@ module Skylight
 
     private
 
-      # We must have an opt-in signal
-      def show_worker_activation_warning(sk_config)
-        reasons = []
-        reasons << "the 'active_job' probe is enabled" if sk_rails_config.probes.include?("active_job")
-        reasons << "the 'delayed_job' probe is enabled" if sk_rails_config.probes.include?("delayed_job")
-        reasons << "SKYLIGHT_ENABLE_SIDEKIQ is set" if sk_config.enable_sidekiq?
+    # We must have an opt-in signal
+    def show_worker_activation_warning(sk_config)
+      reasons = []
+      reasons << "the 'active_job' probe is enabled" if sk_rails_config.probes.include?("active_job")
+      reasons << "the 'delayed_job' probe is enabled" if sk_rails_config.probes.include?("delayed_job")
+      reasons << "SKYLIGHT_ENABLE_SIDEKIQ is set" if sk_config.enable_sidekiq?
 
-        return if reasons.empty?
+      return if reasons.empty?
 
-        sk_config.logger.warn("Activating Skylight for Background Jobs because #{reasons.to_sentence}")
-      end
+      sk_config.logger.warn("Activating Skylight for Background Jobs because #{reasons.to_sentence}")
+    end
 
-      def log_prefix
-        "[SKYLIGHT] [#{Skylight::VERSION}]"
-      end
+    def log_prefix
+      "[SKYLIGHT] [#{Skylight::VERSION}]"
+    end
 
-      def development_warning
-        "#{log_prefix} Running Skylight in development mode. No data will be reported until you deploy your app.\n" \
-          "(To disable this message for all local apps, run `skylight disable_dev_warning`.)"
-      end
+    def development_warning
+      "#{log_prefix} Running Skylight in development mode. No data will be reported until you deploy your app.\n" \
+        "(To disable this message for all local apps, run `skylight disable_dev_warning`.)"
+    end
 
-      def run_initializer(app)
-        # Load probes even when agent is inactive to catch probe related bugs sooner
-        load_probes
+    def run_initializer(app)
+      # Load probes even when agent is inactive to catch probe related bugs sooner
+      load_probes
 
-        config = load_skylight_config(app)
+      config = load_skylight_config(app)
 
-        if activate?(config)
-          if config
-            if Skylight.start!(config)
-              set_middleware_position(app, config)
-              Rails.logger.info "#{log_prefix} Skylight agent enabled"
-            else
-              Rails.logger.info "#{log_prefix} Unable to start, see the Skylight logs for more details"
-            end
-          end
-        elsif Rails.env.development?
-          unless config.user_config.disable_dev_warning?
-            log_warning config, development_warning
-          end
-        elsif !Rails.env.test?
-          unless config.user_config.disable_env_warning?
-            log_warning config, "#{log_prefix} You are running in the #{Rails.env} environment but haven't added it " \
-                                "to config.skylight.environments, so no data will be sent to Skylight servers."
+      if activate?(config)
+        if config
+          if Skylight.start!(config)
+            set_middleware_position(app, config)
+            Rails.logger.info "#{log_prefix} Skylight agent enabled"
+          else
+            Rails.logger.info "#{log_prefix} Unable to start, see the Skylight logs for more details"
           end
         end
-      rescue Skylight::ConfigError => e
-        Rails.logger.error "#{log_prefix} #{e.message}; disabling Skylight agent"
-      end
-
-      def log_warning(config, msg)
-        if config
-          config.alert_logger.warn(msg)
-        else
-          Rails.logger.warn(msg)
+      elsif Rails.env.development?
+        log_warning config, development_warning unless config.user_config.disable_dev_warning?
+      elsif !Rails.env.test?
+        unless config.user_config.disable_env_warning?
+          log_warning config,
+                      "#{log_prefix} You are running in the #{Rails.env} environment but haven't added it " \
+                        "to config.skylight.environments, so no data will be sent to Skylight servers."
         end
       end
+    rescue Skylight::ConfigError => e
+      Rails.logger.error "#{log_prefix} #{e.message}; disabling Skylight agent"
+    end
 
-      def existent_paths(paths)
-        paths.respond_to?(:existent) ? paths.existent : paths.select { |f| File.exist?(f) }
-      end
+    def log_warning(config, msg)
+      config ? config.alert_logger.warn(msg) : Rails.logger.warn(msg)
+    end
 
-      def load_skylight_config(app)
-        path = config_path(app)
-        path = nil unless File.exist?(path)
+    def existent_paths(paths)
+      paths.respond_to?(:existent) ? paths.existent : paths.select { |f| File.exist?(f) }
+    end
 
-        unless (tmp = app.config.paths["tmp"].first)
-          Rails.logger.error "#{log_prefix} tmp directory missing from rails configuration"
-          return nil
-        end
+    def load_skylight_config(app)
+      path = config_path(app)
+      path = nil unless File.exist?(path)
 
-        config = Config.load(file: path, priority_key: Rails.env.to_s)
-        config[:root] = Rails.root
+      unless (tmp = app.config.paths["tmp"].first)
+        Rails.logger.error "#{log_prefix} tmp directory missing from rails configuration"
+        return nil
+      end
 
-        configure_logging(config, app)
+      config = Config.load(file: path, priority_key: Rails.env.to_s)
+      config[:root] = Rails.root
 
-        config[:'daemon.sockdir_path'] ||= tmp
-        config[:'normalizers.render.view_paths'] = existent_paths(app.config.paths["app/views"]) + [Rails.root.to_s]
+      configure_logging(config, app)
 
-        if config[:report_rails_env]
-          config[:env] ||= Rails.env.to_s
-        end
+      config[:'daemon.sockdir_path'] ||= tmp
+      config[:'normalizers.render.view_paths'] = existent_paths(app.config.paths["app/views"]) + [Rails.root.to_s]
 
-        config
-      end
+      config[:env] ||= Rails.env.to_s if config[:report_rails_env]
 
-      def configure_logging(config, app)
-        if (logger = sk_rails_config(app).logger)
-          config.logger = logger
-        else
-          # Configure the log file destination
-          if (log_file = sk_rails_config(app).log_file)
-            config["log_file"] = log_file
-          end
+      config
+    end
 
-          if (native_log_file = sk_rails_config(app).native_log_file)
-            config["native_log_file"] = native_log_file
-          end
+    def configure_logging(config, app)
+      if (logger = sk_rails_config(app).logger)
+        config.logger = logger
+      else
+        # Configure the log file destination
+        if (log_file = sk_rails_config(app).log_file)
+          config["log_file"] = log_file
+        end
 
-          if !config.key?("log_file") && !config.on_heroku?
-            config["log_file"] = File.join(Rails.root, "log/skylight.log")
-          end
+        if (native_log_file = sk_rails_config(app).native_log_file)
+          config["native_log_file"] = native_log_file
+        end
 
-          # Configure the log level
-          if (level = sk_rails_config(app).log_level)
+        config["log_file"] = File.join(Rails.root, "log/skylight.log") if !config.key?("log_file") && !config.on_heroku?
+
+        # Configure the log level
+        if (level = sk_rails_config(app).log_level)
+          config["log_level"] = level
+        elsif !config.key?("log_level")
+          if (level = app.config.log_level)
             config["log_level"] = level
-          elsif !config.key?("log_level")
-            if (level = app.config.log_level)
-              config["log_level"] = level
-            end
           end
         end
       end
+    end
 
-      def config_path(app)
-        File.expand_path(sk_rails_config.config_path, app.root)
-      end
+    def config_path(app)
+      File.expand_path(sk_rails_config.config_path, app.root)
+    end
 
-      def environments
-        Array(sk_rails_config.environments).map { |e| e&.to_s }.compact
-      end
+    def environments
+      Array(sk_rails_config.environments).map { |e| e&.to_s }.compact
+    end
 
-      def activate?(sk_config)
-        return false unless sk_config
+    def activate?(sk_config)
+      return false unless sk_config
 
-        key = "SKYLIGHT_ENABLED"
-        activate =
-          if ENV.key?(key)
-            ENV[key] !~ /^false$/i
-          else
-            environments.include?(Rails.env.to_s)
-          end
+      key = "SKYLIGHT_ENABLED"
+      activate = ENV.key?(key) ? ENV[key] !~ /^false$/i : environments.include?(Rails.env.to_s)
 
-        show_worker_activation_warning(sk_config) if activate
+      show_worker_activation_warning(sk_config) if activate
 
-        activate
-      end
+      activate
+    end
 
-      def load_probes
-        probes = sk_rails_config.probes || []
-        Skylight::Probes.probe(*probes)
-      end
+    def load_probes
+      probes = sk_rails_config.probes || []
+      Skylight::Probes.probe(*probes)
+    end
 
-      def middleware_position
-        if sk_rails_config.middleware_position.is_a?(Hash)
-          sk_rails_config.middleware_position.symbolize_keys
-        else
-          sk_rails_config.middleware_position
-        end
+    def middleware_position
+      if sk_rails_config.middleware_position.is_a?(Hash)
+        sk_rails_config.middleware_position.symbolize_keys
+      else
+        sk_rails_config.middleware_position
       end
+    end
 
-      def insert_middleware(app, config)
-        if middleware_position.key?(:after)
-          app.middleware.insert_after(middleware_position[:after], Skylight::Middleware, config: config)
-        elsif middleware_position.key?(:before)
-          app.middleware.insert_before(middleware_position[:before], Skylight::Middleware, config: config)
-        else
-          raise "The middleware position you have set is invalid. Please be sure " \
+    def insert_middleware(app, config)
+      if middleware_position.key?(:after)
+        app.middleware.insert_after(middleware_position[:after], Skylight::Middleware, config: config)
+      elsif middleware_position.key?(:before)
+        app.middleware.insert_before(middleware_position[:before], Skylight::Middleware, config: config)
+      else
+        raise "The middleware position you have set is invalid. Please be sure " \
                 "`config.skylight.middleware_position` is set up correctly."
-        end
       end
+    end
 
-      def set_middleware_position(app, config)
-        if middleware_position.is_a?(Integer)
-          app.middleware.insert middleware_position, Skylight::Middleware, config: config
-        elsif middleware_position.is_a?(Hash) && middleware_position.keys.count == 1
-          insert_middleware(app, config)
-        elsif middleware_position.nil?
-          app.middleware.insert 0, Skylight::Middleware, config: config
-        else
-          raise "The middleware position you have set is invalid. Please be sure " \
+    def set_middleware_position(app, config)
+      if middleware_position.is_a?(Integer)
+        app.middleware.insert middleware_position, Skylight::Middleware, config: config
+      elsif middleware_position.is_a?(Hash) && middleware_position.keys.count == 1
+        insert_middleware(app, config)
+      elsif middleware_position.nil?
+        app.middleware.insert 0, Skylight::Middleware, config: config
+      else
+        raise "The middleware position you have set is invalid. Please be sure " \
                 "`config.skylight.middleware_position` is set up correctly."
-        end
       end
+    end
 
-      def sk_rails_config(target = self)
-        target.config.skylight
-      end
+    def sk_rails_config(target = self)
+      target.config.skylight
+    end
   end
 end