skylight 4.2.1 → 5.0.0.beta

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, environment: 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

data/lib/skylight/sidekiq.rb

@@ -0,0 +1,43 @@
+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"]
+        Skylight.trace(title, "app.sidekiq.worker", title, segment: queue, component: :worker) do |trace|
+          begin
+            yield
+          rescue Exception # includes Sidekiq::Shutdown
+            trace.segment = "error" if trace
+            raise
+          end
+        end
+      end
+    end
+
+    ActiveSupport::Notifications.subscribe("started_instrumenter.skylight") \
+        do |_name, _started, _finished, _unique_id, payload|
+      if payload[:instrumenter].config.enable_sidekiq?
+        add_middleware
+      end
+    end
+  end
+end

data/lib/skylight/subscriber.rb

@@ -0,0 +1,110 @@
+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.keys.each do |key|
+        @subscribers << ActiveSupport::Notifications.subscribe(key, self)
+      end
+    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
+
+    def start(name, _id, payload)
+      return if @instrumenter.disabled?
+      return unless (trace = @instrumenter.current_trace)
+
+      _start(trace, name, payload)
+    end
+
+    def finish(name, _id, payload)
+      return if @instrumenter.disabled?
+      return unless (trace = @instrumenter.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
+
+    private
+
+      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,146 @@
+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 self.native_new(*)
+                allocate
+              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 = allocate
+                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