skylight 4.2.3 → 5.3.0

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
@@ -21,7 +16,15 @@ 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 = %w[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 }`
@@ -33,34 +36,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

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["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)
+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

data/lib/skylight/test.rb

@@ -0,0 +1,147 @@
+module Skylight
+  module Test
+    module Mocking
+      def mock!(config_opts = {}, &callback)
+        config_opts[:mock_submission] ||= callback || proc {}
+
+        config_class =
+          Class.new(Config) do
+            def validate_with_server
+              true
+            end
+          end
+
+        config = config_class.load(config_opts)
+        config[:authentication] ||= "zomg"
+
+        class_eval do
+          unless const_defined?(:OriginalInstrumenter)
+            const_set :OriginalInstrumenter, Instrumenter
+            remove_const :Instrumenter
+            const_set(
+              :Instrumenter,
+              Class.new(OriginalInstrumenter) do
+                def self.name
+                  "Mocked Instrumenter"
+                end
+
+                def native_start
+                  true
+                end
+
+                def native_submit_trace(trace)
+                  config[:mock_submission].call(trace)
+                end
+
+                def native_stop; end
+              end
+            )
+
+            const_set :OriginalTrace, Trace
+            remove_const :Trace
+            const_set(
+              :Trace,
+              Class.new(OriginalTrace) do
+                def self.native_new(start, _uuid, endpoint, meta)
+                  inst = super
+                  inst.instance_variable_set(:@start, start)
+                  inst.instance_variable_set(:@endpoint, endpoint)
+                  inst.instance_variable_set(:@starting_endpoint, endpoint)
+                  inst.instance_variable_set(:@meta, meta)
+                  inst
+                end
+
+                attr_reader :endpoint, :starting_endpoint, :meta
+
+                def mock_spans
+                  @mock_spans ||= []
+                end
+
+                def filter_spans
+                  if block_given?
+                    mock_spans.select { |span| yield span }
+                  else
+                    mock_spans.reject { |span| span[:cat] == "noise.gc" }
+                  end
+                end
+
+                def native_get_uuid
+                  @uuid
+                end
+
+                def uuid=(value)
+                  @uuid = value
+                end
+
+                def native_get_started_at
+                  @start
+                end
+
+                def native_set_endpoint(endpoint)
+                  @endpoint = endpoint
+                end
+
+                def native_set_component(component)
+                  @component = component
+                end
+
+                def native_start_span(time, cat)
+                  span = { start: time, cat: cat }
+                  mock_spans << span
+
+                  # Return integer like the native method does
+                  mock_spans.index(span)
+                end
+
+                def native_span_set_title(span, title)
+                  mock_spans[span][:title] = title
+                end
+
+                def native_span_set_description(span, desc)
+                  mock_spans[span][:desc] = desc
+                end
+
+                def native_span_set_meta(span, meta)
+                  mock_spans[span][:meta] = meta
+                end
+
+                def native_span_started(span); end
+
+                def native_span_set_exception(span, exception_object, exception)
+                  mock_spans[span][:exception_object] = exception_object
+                  mock_spans[span][:exception] = exception
+                end
+
+                def native_stop_span(span, time)
+                  span = mock_spans[span]
+                  span[:duration] = time - span[:start]
+                  nil
+                end
+
+                def native_use_pruning
+                  @using_native_pruning = true
+                end
+              end
+            )
+          end
+        end
+
+        start!(config)
+      end
+
+      def unmock!
+        if const_defined?(:OriginalInstrumenter)
+          class_eval do
+            remove_const :Instrumenter
+            const_set :Instrumenter, OriginalInstrumenter
+            remove_const :OriginalInstrumenter
+
+            remove_const :Trace
+            const_set :Trace, OriginalTrace
+            remove_const :OriginalTrace
+          end
+        end
+      end
+    end
+  end
+end