truex-skylight 0.6.0

data/lib/skylight/probes.rb

@@ -0,0 +1,91 @@
+module Skylight
+  # @api private
+  module Probes
+    class ProbeRegistration
+      attr_reader :klass_name, :require_paths, :probe
+
+      def initialize(klass_name, require_paths, probe)
+        @klass_name = klass_name
+        @require_paths = Array(require_paths)
+        @probe = probe
+      end
+
+      def install
+        probe.install
+      end
+    end
+
+    def self.require_hooks
+      @require_hooks ||= {}
+    end
+
+    def self.installed
+      @installed ||= {}
+    end
+
+    def self.is_available?(klass_name)
+      !!Skylight::Util::Inflector.safe_constantize(klass_name)
+    end
+
+    def self.register(*args)
+      registration = ProbeRegistration.new(*args)
+
+      if is_available?(registration.klass_name)
+        installed[registration.klass_name] = registration
+        registration.install
+      else
+        register_require_hook(registration)
+      end
+    end
+
+    def self.require_hook(require_path)
+      return unless Skylight.native?
+
+      registration = lookup_by_require_path(require_path)
+      return unless registration
+
+      # Double check constant is available
+      if is_available?(registration.klass_name)
+        installed[registration.klass_name] = registration
+        registration.install
+
+        # Don't need this to be called again
+        unregister_require_hook(registration)
+      end
+    end
+
+    def self.register_require_hook(registration)
+      registration.require_paths.each do |p|
+        require_hooks[p] = registration
+      end
+    end
+
+    def self.unregister_require_hook(registration)
+      registration.require_paths.each do |p|
+        require_hooks.delete(p)
+      end
+    end
+
+    def self.lookup_by_require_path(require_path)
+      require_hooks[require_path]
+    end
+  end
+end
+
+# Allow hooking require
+# @api private
+module ::Kernel
+  alias require_without_sk require
+
+  def require(name)
+    ret = require_without_sk(name)
+
+    begin
+      Skylight::Probes.require_hook(name)
+    rescue Exception
+      # FIXME: Log these errors
+    end
+
+    ret
+  end
+end

data/lib/skylight/probes/excon.rb

@@ -0,0 +1,25 @@
+module Skylight
+  module Probes
+    module Excon
+      class Probe
+        def install
+          if defined?(::Excon::Middleware)
+            # Don't require until installation since it depends on Excon being loaded
+            require 'skylight/probes/excon/middleware'
+
+            idx = ::Excon.defaults[:middlewares].index(::Excon::Middleware::Instrumentor)
+
+            # TODO: Handle possibility of idx being nil
+            ::Excon.defaults[:middlewares].insert(idx, Skylight::Probes::Excon::Middleware)
+          else
+            # Using $stderr here isn't great, but we don't have a logger accessible
+            $stderr.puts "[SKYLIGHT] [#{Skylight::VERSION}] The installed version of Excon doesn't " \
+                          "support Middlewares. The Excon probe will be disabled."
+          end
+        end
+      end
+    end
+
+    register("Excon", "excon", Excon::Probe.new)
+  end
+end

data/lib/skylight/probes/excon/middleware.rb

@@ -0,0 +1,65 @@
+require 'skylight/formatters/http'
+
+module Skylight
+  module Probes
+    module Excon
+      class Middleware < ::Excon::Middleware::Base
+
+        # This probably won't work since config isn't defined
+        include Util::Logging
+
+        def initialize(*)
+          @requests = {}
+          super
+        end
+
+        # TODO:
+        # - Consider whether a LIFO queue would be sufficient
+        # - Check that errors can't be called without a request
+
+        def request_call(datum)
+          begin_instrumentation(datum)
+          super
+        end
+
+        def response_call(datum)
+          super
+        ensure
+          end_instrumentation(datum)
+        end
+
+        def error_call(datum)
+          super
+        ensure
+          end_instrumentation(datum)
+        end
+
+        private
+
+          def begin_instrumentation(datum)
+            method = datum[:method].to_s
+            scheme = datum[:scheme]
+            host   = datum[:host]
+            # TODO: Maybe don't show other default ports like 443
+            port   = datum[:port] != 80 ? datum[:port] : nil
+            path   = datum[:path]
+            query  = datum[:query]
+
+            opts = Formatters::HTTP.build_opts(method, scheme, host, port, path, query)
+
+            @requests[datum.object_id] = Skylight.instrument(opts)
+          rescue Exception => e
+            error "failed to begin instrumentation for Excon; msg=%s", e.message
+          end
+
+          def end_instrumentation(datum)
+            @requests[datum.object_id].done
+            @requests.delete(datum)
+          rescue Exception => e
+            error "failed to end instrumentation for Excon; msg=%s", e.message
+          end
+
+      end
+    end
+  end
+end

data/lib/skylight/probes/net_http.rb

@@ -0,0 +1,44 @@
+require 'skylight/formatters/http'
+
+module Skylight
+  module Probes
+    module NetHTTP
+      class Probe
+        def install
+          Net::HTTP.class_eval do
+            alias request_without_sk request
+
+            def request(req, body = nil, &block)
+              unless started?
+                return request_without_sk(req, body, &block)
+              end
+
+              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 ||= self.address
+              port ||= self.port
+
+              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) do
+                request_without_sk(req, body, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register("Net::HTTP", "net/http", NetHTTP::Probe.new)
+  end
+end

data/lib/skylight/probes/redis.rb

@@ -0,0 +1,30 @@
+module Skylight
+  module Probes
+    module Redis
+      class Probe
+        def install
+          ::Redis::Client.class_eval do
+            alias call_without_sk call
+
+            def call(command, &block)
+              command_name = command[0]
+
+              return call_without_sk(command, &block) if command_name == :auth
+
+              opts = {
+                category: "db.redis.command",
+                title:    command_name.upcase.to_s
+              }
+
+              Skylight.instrument(opts) do
+                call_without_sk(command, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register("Redis", "redis", Redis::Probe.new)
+  end
+end

data/lib/skylight/probes/sequel.rb

@@ -0,0 +1,30 @@
+# Supports 3.12.0+
+module Skylight
+  module Probes
+    module Sequel
+      class Probe
+        def install
+          require 'sequel/database/logging'
+          ::Sequel::Database.class_eval do
+            alias log_yield_without_sk log_yield
+
+            def log_yield(sql, args=nil, &block)
+              log_yield_without_sk(sql, *args) do
+                ::ActiveSupport::Notifications.instrument(
+                  "sql.sequel",
+                  sql: sql,
+                  name: "SQL",
+                  binds: args
+                ) do
+                  block.call
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register("Sequel", "sequel", Sequel::Probe.new)
+  end
+end

data/lib/skylight/probes/sinatra.rb

@@ -0,0 +1,74 @@
+module Skylight
+  module Probes
+    module Sinatra
+      class Probe
+        def install
+          class << ::Sinatra::Base
+            alias build_without_sk build
+            alias compile_without_sk! compile!
+
+            def compile!(verb, path, *args, &block)
+              compile_without_sk!(verb, path, *args, &block).tap do |_, _, _, 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
+
+                # Newer versions of Sinatra populate env['sinatra.route']. Polyfill older
+                # versions in a targeted but hackish way.
+                if ::Sinatra::VERSION < '1.4.0'
+                  def wrapper.[](app, args)
+                    app.env['sinatra.route'] = @route_name
+                    super
+                  end
+                end
+              end
+            end
+
+            def build(*args, &block)
+              self.use Skylight::Middleware
+              build_without_sk(*args, &block)
+            end
+          end
+
+          ::Sinatra::Base.class_eval do
+            alias dispatch_without_sk! dispatch!
+            alias compile_template_without_sk compile_template
+
+            def dispatch!(*args, &block)
+              dispatch_without_sk!(*args, &block).tap do
+                instrumenter = Skylight::Instrumenter.instance
+                next unless instrumenter
+                trace = instrumenter.current_trace
+                next unless trace
+
+                # Set the endpoint name to the route name
+                route = env['sinatra.route']
+                trace.endpoint = route if route
+              end
+            end
+
+            def compile_template(engine, data, options, *args, &block)
+              # Pass along a useful "virtual path" to Tilt. The Tilt probe will handle
+              # instrumenting correctly.
+              case data
+              when Symbol
+                options[:sky_virtual_path] = data.to_s
+              else
+                options[:sky_virtual_path] = "Inline template (#{engine})"
+              end
+
+              compile_template_without_sk(engine, data, options, *args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    register("Sinatra::Base", "sinatra/base", Sinatra::Probe.new)
+  end
+end

data/lib/skylight/probes/tilt.rb

@@ -0,0 +1,27 @@
+# Supports 0.2+, though Sinatra doesn't support 2.0, and Rails doesn't work with older versions
+module Skylight
+  module Probes
+    module Tilt
+      class Probe
+        def install
+          ::Tilt::Template.class_eval do
+            alias render_without_sk render
+
+            def render(*args, &block)
+              opts = {
+                category: "view.render.template",
+                title: options[:sky_virtual_path] || "Unknown template name"
+              }
+
+              Skylight.instrument(opts) do
+                render_without_sk(*args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register("Tilt::Template", "tilt/template", Tilt::Probe.new)
+  end
+end

data/lib/skylight/railtie.rb

@@ -0,0 +1,122 @@
+require 'skylight'
+require 'rails'
+
+module Skylight
+  # @api private
+  class Railtie < Rails::Railtie
+    config.skylight = ActiveSupport::OrderedOptions.new
+
+    # The environments in which skylight should be enabled
+    config.skylight.environments = ['production']
+
+    # The path to the configuration file
+    config.skylight.config_path = "config/skylight.yml"
+
+    # The probes to load
+    #   net_http is on by default
+    #   Also available: excon, redis
+    config.skylight.probes = ['net_http']
+
+    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
+          if Instrumenter.start!(config)
+            app.middleware.insert 0, Middleware, config: config
+            Rails.logger.info "[SKYLIGHT] [#{Skylight::VERSION}] Skylight agent enabled"
+          else
+            Rails.logger.info "[SKYLIGHT] [#{Skylight::VERSION}] Unable to start"
+          end
+        end
+      elsif Rails.env.development?
+        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, set `alert_log_file` in your config.)"
+      elsif !Rails.env.test?
+        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
+
+  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.validate!
+      config
+
+    rescue ConfigError => e
+      Rails.logger.error "[SKYLIGHT] [#{Skylight::VERSION}] #{e.message}; disabling Skylight agent"
+      nil
+    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['log_file'] = File.join(Rails.root, 'log/skylight.log')
+        end
+
+        # 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
+      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?
+      environments.include?(Rails.env.to_s)
+    end
+
+    def load_probes
+      probes = config.skylight.probes || []
+      probes.each do |p|
+        require "skylight/probes/#{p}"
+      end
+    end
+  end
+end