skylight 5.1.0.beta → 5.1.0.beta2

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

data/lib/skylight/sidekiq.rb

@@ -38,11 +38,10 @@ module Skylight
       end
     end
 
-    ActiveSupport::Notifications.subscribe("started_instrumenter.skylight") \
-        do |_name, _started, _finished, _unique_id, payload|
-      if payload[:instrumenter].config.enable_sidekiq?
-        add_middleware
-      end
+    ActiveSupport::Notifications.subscribe(
+      "started_instrumenter.skylight"
+    ) do |_name, _started, _finished, _unique_id, payload|
+      add_middleware if payload[:instrumenter].config.enable_sidekiq?
     end
   end
 end

data/lib/skylight/subscriber.rb

@@ -6,17 +6,15 @@ module Skylight
     attr_reader :config, :normalizers
 
     def initialize(config, instrumenter)
-      @config       = config
-      @normalizers  = Normalizers.build(config)
+      @config = config
+      @normalizers = Normalizers.build(config)
       @instrumenter = instrumenter
-      @subscribers  = []
+      @subscribers = []
     end
 
     def register!
       unregister!
-      @normalizers.keys.each do |key| # rubocop:disable Style/HashEachMethods
-        @subscribers << ActiveSupport::Notifications.subscribe(key, self)
-      end
+      @normalizers.each_key { |key| @subscribers << ActiveSupport::Notifications.subscribe(key, self) }
     end
 
     def unregister!
@@ -74,37 +72,37 @@ module Skylight
 
     private
 
-      def normalize(*args)
-        @normalizers.normalize(*args)
-      end
-
-      def normalize_after(*args)
-        @normalizers.normalize_after(*args)
-      end
+    def normalize(*args)
+      @normalizers.normalize(*args)
+    end
 
-      def _start(trace, name, payload)
-        result = normalize(trace, name, payload)
+    def normalize_after(*args)
+      @normalizers.normalize_after(*args)
+    end
 
-        unless result == :skip
-          case result.size
-          when 3, 4
-            cat, title, desc, meta = result
-          else
-            raise "Invalid normalizer result: #{result.inspect}"
-          end
+    def _start(trace, name, payload)
+      result = normalize(trace, name, payload)
 
-          span = trace.instrument(cat, title, desc, meta)
+      unless result == :skip
+        case result.size
+        when 3, 4
+          cat, title, desc, meta = result
+        else
+          raise "Invalid normalizer result: #{result.inspect}"
         end
-      rescue Exception => e
-        error "Subscriber#start error; msg=%s", e.message
-        debug "trace=%s", trace.inspect
-        debug "in:  name=%s", name.inspect
-        debug "in:  payload=%s", payload.inspect
-        debug "out: cat=%s, title=%s, desc=%s", cat.inspect, name.inspect, desc.inspect
-        t { e.backtrace.join("\n") }
-        nil
-      ensure
-        trace.notifications << Notification.new(name, span)
+
+        span = trace.instrument(cat, title, desc, meta)
       end
+    rescue Exception => e
+      error "Subscriber#start error; msg=%s", e.message
+      debug "trace=%s", trace.inspect
+      debug "in:  name=%s", name.inspect
+      debug "in:  payload=%s", payload.inspect
+      debug "out: cat=%s, title=%s, desc=%s", cat.inspect, name.inspect, desc.inspect
+      t { e.backtrace.join("\n") }
+      nil
+    ensure
+      trace.notifications << Notification.new(name, span)
+    end
   end
 end