skylight 4.3.2 → 5.1.1

data/lib/skylight/probes/mongoid.rb

@@ -0,0 +1,13 @@
+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

data/lib/skylight/probes/net_http.rb

@@ -0,0 +1,54 @@
+require "skylight/formatters/http"
+
+module Skylight
+  module Probes
+    module NetHTTP
+      module Instrumentation
+        def request(req, *)
+          return super if !started? || Probes::NetHTTP::Probe.disabled?
+
+          method = req.method
+
+          # req['host'] also includes special handling for default ports
+          host, port = req["host"] ? req["host"].split(":") : nil
+
+          # If we're connected with a persistent socket
+          host ||= address
+
+          path = req.path
+          scheme = use_ssl? ? "https" : "http"
+
+          # Contained in the path
+          query = nil
+
+          opts = Formatters::HTTP.build_opts(method, scheme, host, port, path, query)
+
+          Skylight.instrument(opts) { super }
+        end
+      end
+
+      # Probe for instrumenting Net::HTTP requests. Works by monkeypatching the default Net::HTTP#request method.
+      class Probe
+        DISABLED_KEY = :__skylight_net_http_disabled
+
+        def self.disable
+          state_was = Thread.current[DISABLED_KEY]
+          Thread.current[DISABLED_KEY] = true
+          yield
+        ensure
+          Thread.current[DISABLED_KEY] = state_was
+        end
+
+        def self.disabled?
+          !!Thread.current[DISABLED_KEY]
+        end
+
+        def install
+          Net::HTTP.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:net_http, "Net::HTTP", "net/http", NetHTTP::Probe.new)
+  end
+end

data/lib/skylight/probes/redis.rb

@@ -0,0 +1,51 @@
+module Skylight
+  module Probes
+    module Redis
+      # 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
+
+      module ClientInstrumentation
+        def call(command, *)
+          command_name = command[0]
+
+          return super if command_name == :auth
+
+          opts = { category: "db.redis.command", title: command_name.upcase.to_s, internal: true }
+
+          Skylight.instrument(opts) { super }
+        end
+      end
+
+      module Instrumentation
+        def pipelined(*)
+          Skylight.instrument(PIPELINED_OPTS) { super }
+        end
+
+        def multi(*)
+          Skylight.instrument(MULTI_OPTS) { super }
+        end
+      end
+
+      class Probe
+        def install
+          version = defined?(::Redis::VERSION) ? Gem::Version.new(::Redis::VERSION) : nil
+
+          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."
+            return
+          end
+
+          ::Redis::Client.prepend(ClientInstrumentation)
+          ::Redis.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:redis, "Redis", "redis", Redis::Probe.new)
+  end
+end

data/lib/skylight/probes/sequel.rb

@@ -0,0 +1,29 @@
+# Supports 3.12.0+
+module Skylight
+  module Probes
+    module Sequel
+      class Probe
+        def install
+          require "sequel/database/logging"
+
+          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
+                  end
+                end
+              end
+            end
+
+          ::Sequel::Database.prepend(mod)
+        end
+      end
+    end
+
+    register(:sequel, "Sequel", "sequel", Sequel::Probe.new)
+  end
+end

data/lib/skylight/probes/sinatra.rb

@@ -0,0 +1,66 @@
+module Skylight
+  module Probes
+    module Sinatra
+      module ClassInstrumentation
+        def compile!(verb, path, *)
+          super.tap do |_, _, keys_or_wrapper, wrapper|
+            wrapper ||= keys_or_wrapper
+
+            # Deal with the situation where the path is a regex, and the default behavior
+            # of Ruby stringification produces an unreadable mess
+            if path.is_a?(Regexp)
+              human_readable = "<sk-regex>%r{#{path.source}}</sk-regex>"
+              wrapper.instance_variable_set(:@route_name, "#{verb} #{human_readable}")
+            else
+              wrapper.instance_variable_set(:@route_name, "#{verb} #{path}")
+            end
+          end
+        end
+      end
+
+      module Instrumentation
+        def dispatch!(*)
+          super.tap do
+            if (trace = Skylight.instrumenter&.current_trace) && (route = env["sinatra.route"])
+              # Include the app's mount point (if available)
+              script_name = trace.instrumenter.config.sinatra_route_prefixes? && env["SCRIPT_NAME"]
+
+              trace.endpoint =
+                if script_name && !script_name.empty?
+                  verb, path = route.split(" ", 2)
+                  "#{verb} [#{script_name}]#{path}"
+                else
+                  route
+                end
+            end
+          end
+        end
+
+        def compile_template(engine, data, options, *)
+          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
+
+      class Probe
+        def install
+          if ::Sinatra::VERSION < "1.4.0"
+            Skylight.error "Sinatra must be version 1.4.0 or greater."
+            return
+          end
+
+          ::Sinatra::Base.singleton_class.prepend(ClassInstrumentation)
+          ::Sinatra::Base.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:sinatra, "Sinatra::Base", "sinatra/base", Sinatra::Probe.new)
+  end
+end

data/lib/skylight/probes/sinatra_add_middleware.rb

@@ -1,20 +1,20 @@
 module Skylight
   module Probes
     module Sinatra
-      class Probe
-        def install
-          class << ::Sinatra::Base
-            alias_method :build_without_sk, :build
+      module Instrumentation
+        def build(*)
+          use Skylight::Middleware
+          super
+        end
+      end
 
-            def build(*args, &block)
-              use Skylight::Middleware
-              build_without_sk(*args, &block)
-            end
-          end
+      class AddMiddlewareProbe
+        def install
+          ::Sinatra::Base.singleton_class.prepend(Instrumentation)
         end
       end
     end
 
-    Skylight::Core::Probes.register(:sinatra_add_middleware, "Sinatra::Base", "sinatra/base", Sinatra::Probe.new)
+    register(:sinatra_add_middleware, "Sinatra::Base", "sinatra/base", Sinatra::AddMiddlewareProbe.new)
   end
 end

data/lib/skylight/probes/tilt.rb

@@ -0,0 +1,25 @@
+# Should support 0.2+, though not tested against older versions
+module Skylight
+  module Probes
+    module Tilt
+      module Instrumentation
+        def render(*args, &block)
+          opts = {
+            category: "view.render.template",
+            title: @__sky_virtual_path || options[:sky_virtual_path] || basename || "Unknown template name"
+          }
+
+          Skylight.instrument(opts) { super(*args, &block) }
+        end
+      end
+
+      class Probe
+        def install
+          ::Tilt::Template.prepend(Instrumentation)
+        end
+      end
+    end
+
+    register(:tilt, "Tilt::Template", "tilt/template", Tilt::Probe.new)
+  end
+end

data/lib/skylight/railtie.rb

@@ -1,14 +1,9 @@
-require "skylight/core/railtie"
+require "skylight"
+require "rails"
 
 module Skylight
+  # @api private
   class Railtie < Rails::Railtie
-    include Skylight::Core::Railtie
-
-    # rubocop:disable Style/SingleLineMethods, Layout/EmptyLineBetweenDefs
-    def self.config_class; Skylight::Config end
-    def self.middleware_class; Skylight::Middleware end
-    # rubocop:enable Style/SingleLineMethods, Layout/EmptyLineBetweenDefs
-
     config.skylight = ActiveSupport::OrderedOptions.new
 
     # The environments in which skylight should be enabled
@@ -33,34 +28,169 @@ module Skylight
 
     private
 
-      def activate?(sk_config)
-        return false unless super && sk_config
-        show_worker_activation_warning(sk_config)
-        true
-      end
+    # 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?
+
+      sk_config.logger.warn("Activating Skylight for Background Jobs because #{reasons.to_sentence}")
+    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
 
-      # 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?
+    def run_initializer(app)
+      # Load probes even when agent is inactive to catch probe related bugs sooner
+      load_probes
 
-        return if reasons.empty?
+      config = load_skylight_config(app)
 
-        sk_config.logger.warn("Activating Skylight for Background Jobs because #{reasons.to_sentence}")
+      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?
+        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 development_warning
-        super + "\n(To disable this message for all local apps, run `skylight disable_dev_warning`.)"
+    def log_warning(config, msg)
+      config ? config.alert_logger.warn(msg) : Rails.logger.warn(msg)
+    end
+
+    def existent_paths(paths)
+      paths.respond_to?(:existent) ? paths.existent : paths.select { |f| File.exist?(f) }
+    end
+
+    def load_skylight_config(app)
+      path = config_path(app)
+      path = nil unless File.exist?(path)
+
+      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)
-        super.tap do |sk_config|
-          if sk_config && sk_config[:report_rails_env]
-            sk_config[:env] ||= Rails.env.to_s
+      config = Config.load(file: path, priority_key: Rails.env.to_s)
+      config[:root] = Rails.root
+
+      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[:env] ||= Rails.env.to_s if config[:report_rails_env]
+
+      config
+    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 (native_log_file = sk_rails_config(app).native_log_file)
+          config["native_log_file"] = native_log_file
+        end
+
+        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
           end
         end
       end
+    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 activate?(sk_config)
+      return false unless sk_config
+
+      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
+
+      activate
+    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
+    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 " \
+                "`config.skylight.middleware_position` is set up correctly."
+      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 " \
+                "`config.skylight.middleware_position` is set up correctly."
+      end
+    end
+
+    def sk_rails_config(target = self)
+      target.config.skylight
+    end
   end
 end