skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/normalizers/active_job/enqueue_at.rb

@@ -1,21 +1,3 @@
-module Skylight
-  module Normalizers
-    module ActiveJob
-      class EnqueueAt < Normalizer
-        register "enqueue_at.active_job", enabled: false
+warn "[DEPRECATED] [SKYLIGHT] [#{Skylight::VERSION}] Require 'skylight/core/normalizers/active_job/enqueue_at' instead of 'skylight/normalizers/active_job/enqueue_at'."
 
-        CAT = "other.job.enqueue_at".freeze
-
-        def normalize(_trace, _name, payload)
-					title = "Enqueue #{payload[:job].class}"
-
-					adapter_class_name = payload[:adapter].class.name
-					adapter_name = adapter_class_name.match(/^ActiveJob::QueueAdapters::(\w+)Adapter$/)[1].underscore
-					desc = "{ adapter: '#{adapter_name}', queue: '#{payload[:job].queue_name}' }"
-
-					[ CAT, title, desc ]
-        end
-      end
-    end
-  end
-end
+require 'skylight/core/normalizers/active_job/enqueue_at'

data/lib/skylight/probes/sinatra_add_middleware.rb

@@ -0,0 +1,22 @@
+module Skylight
+  module Probes
+    module Sinatra
+      class Probe
+        def install
+          puts "Installed"
+          class << ::Sinatra::Base
+            alias build_without_sk build
+
+            def build(*args, &block)
+              puts "Using Middleware"
+              self.use Skylight::Middleware
+              build_without_sk(*args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    Skylight::Core::Probes.register("Sinatra::Base", "sinatra/base", Sinatra::Probe.new)
+  end
+end

data/lib/skylight/railtie.rb

@@ -1,9 +1,12 @@
-require 'skylight'
-require 'rails'
+require 'skylight/core/railtie'
 
 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
@@ -16,144 +19,21 @@ module Skylight
     #   net_http, action_controller, action_view, middleware, and grape 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_dispatch', 'action_controller', 'action_view', 'middleware', 'grape']
+    config.skylight.probes = ['net_http', 'action_controller', 'action_view', 'middleware', 'grape']
 
     # 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|
-      # Load probes even when agent is inactive to catch probe related bugs sooner
-      load_probes
-
-      config = load_skylight_config(app)
-
-      if activate?
-        if config
-          begin
-            if Instrumenter.start!(config)
-              set_middleware_position(app, config)
-              Rails.logger.info "[SKYLIGHT] [#{Skylight::VERSION}] Skylight agent enabled"
-            else
-              Rails.logger.info "[SKYLIGHT] [#{Skylight::VERSION}] Unable to start, see the Skylight logs for more details"
-            end
-          rescue ConfigError => e
-            Rails.logger.error "[SKYLIGHT] [#{Skylight::VERSION}] #{e.message}; disabling Skylight agent"
-          end
-        end
-      elsif Rails.env.development?
-        unless config.user_config.disable_dev_warning?
-          log_warning config, "[SKYLIGHT] [#{Skylight::VERSION}] 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
-      elsif !Rails.env.test?
-        unless config.user_config.disable_env_warning?
-          log_warning config, "[SKYLIGHT] [#{Skylight::VERSION}] 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.io."
-        end
-      end
-    end
-
-  private
-
-    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.exists?(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 "[SKYLIGHT] [#{Skylight::VERSION}] 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]
-      config
+      run_initializer(app)
     end
 
-    def configure_logging(config, app)
-      if logger = app.config.skylight.logger
-        config.logger = logger
-      else
-        # Configure the log file destination
-        if log_file = app.config.skylight.log_file
-          config['log_file'] = log_file
-        elsif !config.key?('log_file') && !config.on_heroku?
-          config['log_file'] = File.join(Rails.root, 'log/skylight.log')
-        end
+    private
 
-        # Configure the log level
-        if level = app.config.skylight.log_level
-          config['log_level'] = level
-        elsif !config.key?('log_level')
-          if level = app.config.log_level
-            config['log_level'] = level
-          end
-        end
+      def development_warning
+        super + "\n(To disable this message for all local apps, run `skylight disable_dev_warning`.)"
       end
-    end
-
-    def config_path(app)
-      File.expand_path(config.skylight.config_path, app.root)
-    end
-
-    def environments
-      Array(config.skylight.environments).map { |e| e && e.to_s }.compact
-    end
-
-    def activate?
-      if ENV.key?("SKYLIGHT_ENABLED")
-        ENV["SKYLIGHT_ENABLED"] !~ /^false$/i
-      else
-        environments.include?(Rails.env.to_s)
-      end
-    end
-
-    def load_probes
-      if probes = config.skylight.probes
-        Skylight.probe(*probes)
-      end
-    end
 
-    def middleware_position
-      config.skylight.middleware_position.is_a?(Hash) ? config.skylight.middleware_position.symbolize_keys : config.skylight.middleware_position
-    end
-
-    def insert_middleware(app, config)
-      if middleware_position.has_key?(:after)
-        app.middleware.insert_after(middleware_position[:after], Skylight::Middleware, config: config)
-      elsif middleware_position.has_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, 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, 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
   end
 end

data/lib/skylight/sinatra.rb

@@ -1,7 +1,3 @@
 require 'skylight'
-
-if Gem::Version(Sinatra::VERSION) < Gem::Version('1.4')
-  Skylight::DEPRECATOR.deprecation_warning("Support for Sinatra versions before 1.4")
-end
-
+require 'skylight/probes/sinatra_add_middleware'
 Skylight.probe(:sinatra, :tilt, :sequel)

data/lib/skylight/trace.rb

@@ -1,232 +1,4 @@
 module Skylight
-  class Trace
-    GC_CAT = 'noise.gc'.freeze
-
-    include Util::Logging
-
-    attr_reader :endpoint, :notifications
-
-    def self.new(instrumenter, endpoint, start, cat, title = nil, desc = nil)
-      inst = native_new(normalize_time(start), "TODO", endpoint)
-      inst.send(:initialize, instrumenter, cat, title, desc)
-      inst.endpoint = endpoint
-      inst
-    end
-
-    # TODO: Move this into native
-    def self.normalize_time(time)
-      # At least one customer has extensions that cause integer division to produce rationals.
-      # Since the native code expects an integer, we force it again.
-      (time.to_i / 100_000).to_i
-    end
-
-    def initialize(instrumenter, cat, title, desc)
-      raise ArgumentError, 'instrumenter is required' unless instrumenter
-
-      @instrumenter = instrumenter
-      @submitted = false
-      @broken = false
-
-      @notifications = []
-
-      @spans = []
-
-      # create the root node
-      @root = start(native_get_started_at, cat, title, desc, normalize: false)
-
-      @gc = config.gc.track unless ENV.key?("SKYLIGHT_DISABLE_GC_TRACKING")
-    end
-
-    def endpoint=(value)
-      @endpoint = value
-      native_set_endpoint(value)
-      value
-    end
-
-    def config
-      @instrumenter.config
-    end
-
-    def broken?
-      !!@broken
-    end
-
-    def record(cat, title=nil, desc=nil)
-      return if broken?
-
-      title.freeze if title.is_a?(String)
-      desc.freeze  if desc.is_a?(String)
-
-      desc = @instrumenter.limited_description(desc)
-
-      time = Util::Clock.nanos - gc_time
-
-      stop(start(time, cat, title, desc), time)
-
-      nil
-    rescue => e
-      error "failed to record span; msg=%s; endpoint=%s", e.message, endpoint
-      broken!
-      nil
-    end
-
-    def instrument(cat, title=nil, desc=nil)
-      return if broken?
-      t { "instrument: #{cat}, #{title}" }
-
-      title.freeze if title.is_a?(String)
-      desc.freeze  if desc.is_a?(String)
-
-      original_desc = desc
-      now           = Util::Clock.nanos
-      desc          = @instrumenter.limited_description(desc)
-
-      if desc == Instrumenter::TOO_MANY_UNIQUES
-        error "[SKYLIGHT] [#{Skylight::VERSION}] [E0002] You've exceeded the number of unique span descriptions per-request " \
-                  "for endpoint: #{endpoint}."
-        debug "original desc=%s", original_desc
-        debug "cat=%s, title=%s, desc=%s", cat, title, desc
-      end
-
-      start(now - gc_time, cat, title, desc)
-    rescue => e
-      error "failed to instrument span; msg=%s; endpoint=%s", e.message, endpoint
-      broken!
-      nil
-    end
-
-    def done(span, meta=nil)
-      return unless span
-      return if broken?
-
-      if meta && meta[:defer]
-        deferred_spans[span] ||= (Util::Clock.nanos - gc_time)
-        return
-      end
-
-      stop(span, Util::Clock.nanos - gc_time)
-    rescue => e
-      error "failed to close span; msg=%s; endpoint=%s", e.message, endpoint
-      broken!
-      nil
-    end
-
-    # Middleware spans that were interrupted by a throw/catch should be cached here.
-    # keys: span ids
-    # values: nsec timestamp at which the span was cached here.
-    def deferred_spans
-      @deferred_spans ||= {}
-    end
-
-    def release
-      return unless @instrumenter.current_trace == self
-      @instrumenter.current_trace = nil
-    end
-
-    def broken!
-      debug "trace is broken"
-      @broken = true
-    end
-
-    def traced
-      time = gc_time
-      now = Util::Clock.nanos
-
-      if time > 0
-        t { fmt "tracking GC time; duration=%d", time }
-        stop(start(now - time, GC_CAT, nil, nil), now)
-      end
-
-      stop(@root, now)
-    end
-
-    def submit
-      t { "submitting trace" }
-
-      # This must always be called to clean up properly
-      release
-
-      if broken?
-        t { "broken, not submitting" }
-        return
-      end
-
-      if @submitted
-        t { "already submitted" }
-        return
-      end
-
-      @submitted = true
-
-      traced
-
-      @instrumenter.process(self)
-    rescue Exception => e
-      error e.message
-      t { e.backtrace.join("\n") }
-    end
-
-  private
-
-    def start(time, cat, title, desc, opts={})
-      time = self.class.normalize_time(time) unless opts[:normalize] == false
-
-      sp = native_start_span(time, cat.to_s)
-      native_span_set_title(sp, title.to_s) if title
-      native_span_set_description(sp, desc.to_s) if desc
-
-      @spans << sp
-      t { "started span: #{sp} - #{cat}, #{title}" }
-
-      sp
-    end
-
-    def stop(span, time)
-      t { "stopping span: #{span}" }
-
-      # If `stop` is called for a span that is not the last item in the stack,
-      # check to see if the last item has been marked as deferred. If so, close
-      # that span first, then try to close the original.
-      while deferred_spans[expected = @spans.pop]
-        normalized_stop(expected, deferred_spans.delete(expected))
-      end
-
-      handle_unexpected_stop(expected, span) unless span == expected
-
-      normalized_stop(span, time)
-      nil
-    end
-
-    def normalized_stop(span, time)
-      time = self.class.normalize_time(time)
-      native_stop_span(span, time)
-    end
-
-    def handle_unexpected_stop(expected, span)
-      message = "[E0001] Spans were closed out of order.\n"
-
-      if Skylight::Util::Logging.trace?
-        message << "Expected #{expected}, but received #{span}. See prior logs to match id to a name.\n" \
-                   "If the received span was a Middleware it may be one that doesn't fully conform to " \
-                   "the Rack SPEC."
-      else
-        message << "To debug this issue set `SKYLIGHT_ENABLE_TRACE_LOGS=true` " \
-                   "in your environment. (Beware, it is quite noisy!)\n"
-      end
-
-      message << "\nThis request will not be tracked. Please contact support@skylight.io for more information."
-
-      error message
-
-      t { "expected=#{expected}, actual=#{span}" }
-
-      broken!
-    end
-
-    def gc_time
-      return 0 unless @gc
-      @gc.update
-      @gc.time
-    end
+  class Trace < Core::Trace
   end
 end