skylight 4.3.2 → 5.0.0.beta5

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,63 @@
+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,33 @@
+# 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,63 @@
+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, *)
+          # 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
+        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,27 @@
+# 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:    options[:sky_virtual_path] || basename || "Unknown template name"
+          }
+
+          Skylight.instrument(opts) do
+            super(*args, &block)
+          end
+        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,12 +28,6 @@ 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 = []
@@ -51,16 +40,171 @@ module Skylight
         sk_config.logger.warn("Activating Skylight for Background Jobs because #{reasons.to_sentence}")
       end
 
+      def log_prefix
+        "[SKYLIGHT] [#{Skylight::VERSION}]"
+      end
+
       def development_warning
-        super + "\n(To disable this message for all local apps, run `skylight disable_dev_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
+
+        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."
+          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)
+        end
+      end
+
+      def existent_paths(paths)
+        paths.respond_to?(:existent) ? paths.existent : paths.select { |f| File.exist?(f) }
       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
+        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
+
+        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]
+
+        if config[:report_rails_env]
+          config[:env] ||= Rails.env.to_s
+        end
+
+        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
+
+          if !config.key?("log_file") && !config.on_heroku?
+            config["log_file"] = File.join(Rails.root, "log/skylight.log")
+          end
+
+          # 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 =
+          if ENV.key?(key)
+            ENV[key] !~ /^false$/i
+          else
+            environments.include?(Rails.env.to_s)
+          end
+
+        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