skylight 3.1.4 → 5.3.4

data/lib/skylight/probes.rb

@@ -0,0 +1,172 @@
+require "pathname"
+require "active_support/inflector"
+
+module Skylight
+  # @api private
+  module Probes
+    class ProbeRegistration
+      attr_reader :name, :const_name, :require_paths, :probe
+
+      def initialize(name, const_name, require_paths, probe)
+        @name = name
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @probe = probe
+      end
+
+      def install
+        probe.install
+      rescue StandardError, LoadError => e
+        log_install_exception(e)
+      end
+
+      def constant_available?
+        Skylight::Probes.constant_available?(const_name)
+      end
+
+      private
+
+      def log_install_exception(err)
+        description = err.class.to_s
+        description << ": #{err.message}" unless err.message.empty?
+
+        backtrace = err.backtrace.map { |l| "  #{l}" }.join("\n")
+
+        # rubocop:disable Lint/SuppressedException
+        gems =
+          begin
+            Bundler.locked_gems.dependencies.map { |d| [d.name, d.requirement.to_s] }
+          rescue StandardError
+          end
+
+        # rubocop:enable Lint/SuppressedException
+
+        error =
+          "[SKYLIGHT] [#{Skylight::VERSION}] Encountered an error while installing the " \
+            "probe for #{const_name}. Please notify support@skylight.io with the debugging " \
+            "information below. It's recommended that you disable this probe until the " \
+            "issue is resolved." \
+            "\n\nERROR: #{description}\n\n#{backtrace}\n\n"
+
+        if gems
+          gems_string = gems.map { |g| "  #{g[0]}   #{g[1]}" }.join("\n")
+          error << "GEMS:\n\n#{gems_string}\n\n"
+        end
+
+        $stderr.puts(error)
+      end
+    end
+
+    class << self
+      def constant_available?(const_name)
+        ::ActiveSupport::Inflector.safe_constantize(const_name).present?
+      end
+
+      def install!
+        pending = registered.values - installed.values
+
+        pending.each do |registration|
+          registration.constant_available? ? install_probe(registration) : register_require_hook(registration)
+        end
+      end
+
+      def install_probe(registration)
+        return if installed.key?(registration.name)
+
+        installed[registration.name] = registration
+        registration.install
+      end
+
+      def add_path(path)
+        Dir.glob("**/*.rb", base: path) do |f|
+          name = Pathname.new(f).sub_ext("").to_s
+          full_path = File.expand_path(f, path)
+
+          raise "duplicate probe name: #{name}; original=#{available[name]}; new=#{full_path}" if available.key?(name)
+
+          available[name] = full_path
+        end
+      end
+
+      def available
+        @available ||= {}
+      end
+
+      def probe(*probes)
+        unknown = probes.map(&:to_s) - available.keys
+        raise ArgumentError, "unknown probes: #{unknown.join(", ")}" unless unknown.empty?
+
+        probes.each { |p| require available[p.to_s] }
+      end
+
+      def registered
+        @registered ||= {}
+      end
+
+      def require_hooks
+        @require_hooks ||= {}
+      end
+
+      def installed
+        @installed ||= {}
+      end
+
+      def register(name, *args)
+        raise "already registered: #{name}" if registered.key?(name)
+
+        registered[name] = ProbeRegistration.new(name, *args)
+
+        true
+      end
+
+      def require_hook(require_path)
+        each_by_require_path(require_path) do |registration|
+          # Double check constant is available
+          next unless registration.constant_available?
+
+          install_probe(registration)
+
+          # Don't need this to be called again
+          unregister_require_hook(registration)
+        end
+      end
+
+      def register_require_hook(registration)
+        registration.require_paths.each do |p|
+          require_hooks[p] ||= []
+          require_hooks[p] << registration
+        end
+      end
+
+      def unregister_require_hook(registration)
+        registration.require_paths.each do |p|
+          require_hooks[p].delete(registration)
+          require_hooks.delete(p) if require_hooks[p].empty?
+        end
+      end
+
+      def each_by_require_path(require_path)
+        return unless require_hooks.key?(require_path)
+
+        # dup because we may be mutating the array
+        require_hooks[require_path].dup.each { |registration| yield registration }
+      end
+    end
+
+    add_path(File.expand_path("./probes", __dir__))
+  end
+end
+
+# @api private
+module Kernel
+  # Unfortunately, we can't use prepend here, in part because RubyGems changes require with an alias
+  alias require_without_sk require
+
+  def require(name)
+    require_without_sk(name).tap do
+      Skylight::Probes.require_hook(name)
+    rescue Exception => e
+      warn("[SKYLIGHT] Rescued exception in require hook", e)
+    end
+  end
+end

data/lib/skylight/railtie.rb

@@ -1,16 +1,13 @@
-require 'skylight/core/railtie'
+require "skylight"
+require "rails"
 
 module Skylight
+  # @api private
   class Railtie < Rails::Railtie
-    include Skylight::Core::Railtie
-
-    def self.config_class; Skylight::Config end
-    def self.middleware_class; Skylight::Middleware end
-
     config.skylight = ActiveSupport::OrderedOptions.new
 
     # The environments in which skylight should be enabled
-    config.skylight.environments = ['production']
+    config.skylight.environments = ["production"]
 
     # The path to the configuration file
     config.skylight.config_path = "config/skylight.yml"
@@ -19,29 +16,189 @@ module Skylight
     #   net_http, action_controller, action_dispatch, action_view, and middleware are on by default
     #   See https://www.skylight.io/support/getting-more-from-skylight#available-instrumentation-options
     #   for a full list.
-    config.skylight.probes = ['net_http', 'action_controller', 'action_dispatch', 'action_view', 'middleware', 'active_job_enqueue']
+    config.skylight.probes = %w[
+      net_http
+      action_controller
+      action_dispatch
+      action_view
+      middleware
+      active_job_enqueue
+      active_record_async
+    ]
 
     # The position in the middleware stack to place Skylight
     # Default is first, but can be `{ after: Middleware::Name }` or `{ before: Middleware::Name }`
     config.skylight.middleware_position = 0
 
-    initializer 'skylight.configure' do |app|
+    initializer "skylight.configure" do |app|
       run_initializer(app)
     end
 
     private
 
-      def development_warning
-        super + "\n(To disable this message for all local apps, run `skylight disable_dev_warning`.)"
+    # 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
+
+    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?
+        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 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 |config|
-          if config[:report_rails_env]
-            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.fetch(key, nil) !~ /^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

data/lib/skylight/sidekiq.rb

@@ -0,0 +1,47 @@
+module Skylight
+  module Sidekiq
+    def self.add_middleware
+      unless defined?(::Sidekiq)
+        Skylight.warn "Skylight for Sidekiq is active, but Sidekiq is not defined."
+        return
+      end
+
+      ::Sidekiq.configure_server do |sidekiq_config|
+        Skylight.debug "Adding Sidekiq Middleware"
+
+        sidekiq_config.server_middleware do |chain|
+          # Put it at the front
+          chain.prepend ServerMiddleware
+        end
+      end
+    end
+
+    class ServerMiddleware
+      include Util::Logging
+
+      def call(worker, job, queue)
+        t { "Sidekiq middleware beginning trace" }
+        title = job["display_class"] || job["wrapped"] || job["class"]
+
+        # 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
+
+    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/sinatra.rb

@@ -1,2 +1,2 @@
-require 'skylight'
-Skylight.probe(:sinatra_add_middleware, :sinatra, :tilt, :sequel)
+require "skylight"
+Skylight.probe(:sinatra_add_middleware, :sinatra, :tilt, :sequel, :rack_builder)

data/lib/skylight/subscriber.rb

@@ -0,0 +1,130 @@
+module Skylight
+  # @api private
+  class Subscriber
+    include Util::Logging
+
+    attr_reader :config, :normalizers
+
+    def initialize(config, instrumenter)
+      @config = config
+      @normalizers = Normalizers.build(config)
+      @instrumenter = instrumenter
+      @subscribers = []
+    end
+
+    def register!
+      unregister!
+      @normalizers.each_key { |key| @subscribers << ActiveSupport::Notifications.subscribe(key, self) }
+    end
+
+    def unregister!
+      ActiveSupport::Notifications.unsubscribe @subscribers.shift until @subscribers.empty?
+    end
+
+    #
+    #
+    # ===== ActiveSupport::Notifications API
+    #
+    #
+
+    class Notification
+      attr_reader :name, :span
+
+      def initialize(name, span)
+        @name = name
+        @span = span
+      end
+    end
+
+    # cargo-culted from Rails's ConnectionAdapter
+    EXCEPTION_NEVER = { Exception => :never }.freeze # :nodoc:
+    EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze # :nodoc:
+    private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
+    def with_trace(trace, &block) # :nodoc:
+      Thread.handle_interrupt(EXCEPTION_NEVER) do
+        previous_trace = @trace
+        @trace = trace
+        Thread.handle_interrupt(EXCEPTION_IMMEDIATE, &block)
+      ensure
+        @trace = previous_trace
+      end
+    end
+
+    def start(name, _id, payload)
+      return if @instrumenter.disabled?
+      return unless (trace = current_trace)
+
+      _start(trace, name, payload)
+    end
+
+    def finish(name, _id, payload)
+      return if @instrumenter.disabled?
+      return unless (trace = current_trace)
+
+      while (curr = trace.notifications.pop)
+        next unless curr.name == name
+
+        meta = {}
+        meta[:exception] = payload[:exception] if payload[:exception]
+        meta[:exception_object] = payload[:exception_object] if payload[:exception_object]
+        trace.done(curr.span, meta) if curr.span
+        normalize_after(trace, curr.span, name, payload)
+        return
+      end
+    rescue Exception => e
+      error "Subscriber#finish error; msg=%s", e.message
+      debug "trace=%s", trace.inspect
+      debug "in:  name=%s", name.inspect
+      debug "in:  payload=%s", payload.inspect
+      t { e.backtrace.join("\n") }
+      nil
+    end
+
+    def publish(name, *args)
+      # Ignored for now because nothing in rails uses it
+    end
+
+    def publish_event(event)
+      # Ignored for now because only ActiveRecord::FutureResult uses it and we handle that with probes
+    end
+
+    private
+
+    def current_trace
+      @trace || @instrumenter.current_trace
+    end
+
+    def normalize(*args)
+      @normalizers.normalize(*args)
+    end
+
+    def normalize_after(*args)
+      @normalizers.normalize_after(*args)
+    end
+
+    def _start(trace, name, payload)
+      result = normalize(trace, name, payload)
+
+      unless result == :skip
+        case result.size
+        when 3, 4
+          cat, title, desc, meta = result
+        else
+          raise "Invalid normalizer result: #{result.inspect}"
+        end
+
+        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