truex-skylight 0.6.0

data/lib/skylight/middleware.rb

@@ -0,0 +1,75 @@
+module Skylight
+  # @api private
+  class Middleware
+
+    class BodyProxy
+      def initialize(body, &block)
+        @body, @block, @closed = body, block, false
+      end
+
+      def respond_to?(*args)
+        return false if args.first.to_s =~ /^to_ary$/
+        super or @body.respond_to?(*args)
+      end
+
+      def close
+        return if @closed
+        @closed = true
+        begin
+          @body.close if @body.respond_to? :close
+        ensure
+          @block.call
+        end
+      end
+
+      def closed?
+        @closed
+      end
+
+      # N.B. This method is a special case to address the bug described by #434.
+      # We are applying this special case for #each only. Future bugs of this
+      # class will be handled by requesting users to patch their ruby
+      # implementation, to save adding too many methods in this class.
+      def each(*args, &block)
+        @body.each(*args, &block)
+      end
+
+      def method_missing(*args, &block)
+        super if args.first.to_s =~ /^to_ary$/
+        @body.__send__(*args, &block)
+      end
+    end
+
+    include Util::Logging
+
+    # For Util::Logging
+    attr_reader :config
+
+    def initialize(app, opts={})
+      @app = app
+      @config = opts[:config]
+    end
+
+    def call(env)
+      if env["REQUEST_METHOD"] == "HEAD"
+        t { "middleware skipping HEAD" }
+        @app.call(env)
+      else
+        begin
+          t { "middleware beginning trace" }
+          trace = Skylight.trace "Rack", 'app.rack.request'
+          resp = @app.call(env)
+          resp[2] = BodyProxy.new(resp[2]) { trace.submit } if trace
+          resp
+        rescue Exception
+          t { "middleware exception: #{trace}"}
+          trace.submit if trace
+          raise
+        ensure
+          t { "middleware release: #{trace}"}
+          trace.release if trace
+        end
+      end
+    end
+  end
+end

data/lib/skylight/native.rb

@@ -0,0 +1,69 @@
+require 'skylight/util/platform'
+
+module Skylight
+  # @api private
+  # Whether or not the native extension is present
+  @@has_native_ext = false
+
+  def self.native?
+    @@has_native_ext
+  end
+
+  def self.libskylight_path
+    ENV['SKYLIGHT_LIB_PATH'] || File.expand_path("../native/#{Util::Platform.tuple}", __FILE__)
+  end
+
+  skylight_required = ENV.key?("SKYLIGHT_REQUIRED") && ENV['SKYLIGHT_REQUIRED'] !~ /^false$/i
+
+  begin
+    unless ENV.key?("SKYLIGHT_DISABLE_AGENT") && ENV['SKYLIGHT_DISABLE_AGENT'] !~ /^false$/i
+      lib = "#{libskylight_path}/libskylight.#{Util::Platform.libext}"
+
+      if File.exist?(lib)
+        # First attempt to require the native extension
+        require "skylight_native"
+
+        # Attempt to link the dylib
+        load_libskylight(lib)
+
+        # If nothing was thrown, then the native extension is present
+        @@has_native_ext = true
+      elsif skylight_required
+        raise LoadError, "Cannot find native extensions in #{libskylight_path}"
+      end
+    end
+  rescue LoadError => e
+    raise if skylight_required
+  end
+
+  unless Skylight.native?
+    class Instrumenter
+      def self.native_new(*args)
+        allocate
+      end
+    end
+  end
+
+  # @api private
+  def self.check_install_errors(config)
+    # Note: An unsupported arch doesn't count as an error.
+    install_log = File.expand_path("../../ext/install.log", __FILE__)
+
+    if File.exist?(install_log) && File.read(install_log) =~ /ERROR/
+      config.alert_logger.error \
+          "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension failed to install. " \
+          "Please check #{install_log} and notify support@skylight.io." \
+          "The missing extension will not affect the functioning of your application."
+    end
+  end
+
+  # @api private
+  def self.warn_skylight_native_missing(config)
+    config.alert_logger.error \
+      "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for " \
+      "your platform wasn't found. Supported operating systems are " \
+      "Linux 2.6.18+ and Mac OS X 10.8+. The missing extension will not " \
+      "affect the functioning of your application. If you are on a " \
+      "supported platform, please contact support at support@skylight.io."
+  end
+end

data/lib/skylight/normalizers.rb

@@ -0,0 +1,133 @@
+require 'skylight/normalizers/default'
+
+module Skylight
+  # @api private
+  # Convert AS::N events to Skylight events
+  module Normalizers
+
+    DEFAULT = Default.new
+
+    def self.register(name, klass)
+      (@registry ||= {})[name] = klass
+      klass
+    end
+
+    def self.build(config)
+      normalizers = {}
+
+      (@registry || {}).each do |k, klass|
+        unless klass.method_defined?(:normalize)
+          # TODO: Warn
+          next
+        end
+
+        normalizers[k] = klass.new(config)
+      end
+
+      Container.new(normalizers)
+    end
+
+    class Normalizer
+      def self.register(name)
+        Normalizers.register(name, self)
+      end
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+        setup if respond_to?(:setup)
+      end
+    end
+
+    class RenderNormalizer < Normalizer
+      include Util::AllocationFree
+
+      def setup
+        @paths = config['normalizers.render.view_paths'] || []
+      end
+
+      def normalize_render(category, payload, annotations)
+        if path = payload[:identifier]
+          title = relative_path(path, annotations)
+          path = nil if path == title
+        end
+
+        [ category, title, nil, annotations ]
+      end
+
+      def relative_path(path, annotations)
+        return path if relative_path?(path)
+
+        root = array_find(@paths) { |p| path.start_with?(p) }
+        type = :project
+
+        unless root
+          root = array_find(Gem.path) { |p| path.start_with?(p) }
+          type = :gem
+        end
+
+        if root
+          start = root.size
+          start += 1 if path.getbyte(start) == SEPARATOR_BYTE
+          if type == :gem
+            "$GEM_PATH/#{path[start, path.size]}"
+          else
+            path[start, path.size]
+          end
+        else
+          "Absolute Path"
+        end
+      end
+
+    private
+      def relative_path?(path)
+        !absolute_path?(path)
+      end
+
+      SEPARATOR_BYTE = File::SEPARATOR.ord
+
+      if File.const_defined?(:NULL) ? File::NULL == "NUL" : RbConfig::CONFIG['host_os'] =~ /mingw|mswin32/
+        # This is a DOSish environment
+        ALT_SEPARATOR_BYTE = File::ALT_SEPARATOR && File::ALT_SEPARATOR.ord
+        COLON_BYTE = ":".ord
+        def absolute_path?(path)
+          if alpha?(path.getbyte(0)) && path.getbyte(1) == COLON_BYTE
+            byte2 = path.getbyte(2)
+            byte2 == SEPARATOR_BYTE || byte2 == ALT_SEPARATOR_BYTE
+          end
+        end
+
+        def alpha?(byte)
+          byte >= 65 and byte <= 90 || byte >= 97 and byte <= 122
+        end
+      else
+        def absolute_path?(path)
+          path.getbyte(0) == SEPARATOR_BYTE
+        end
+      end
+    end
+
+    class Container
+      def initialize(normalizers)
+        @normalizers = normalizers
+      end
+
+      def normalize(trace, name, payload)
+        normalizer = @normalizers[name] || DEFAULT
+        normalizer.normalize(trace, name, payload)
+      end
+    end
+
+    %w( action_controller/process_action
+        action_controller/send_file
+        action_view/render_collection
+        action_view/render_partial
+        action_view/render_template
+        active_record/sql
+        active_support/cache
+        moped/query).each do |file|
+      require "skylight/normalizers/#{file}"
+    end
+  end
+end

data/lib/skylight/normalizers/action_controller/process_action.rb

@@ -0,0 +1,35 @@
+module Skylight
+  module Normalizers
+    module ActionController
+      class ProcessAction < Normalizer
+        register "process_action.action_controller"
+
+        CAT = "app.controller.request".freeze
+        PAYLOAD_KEYS = %w[ controller action params format method path ].map(&:to_sym).freeze
+
+        def normalize(trace, name, payload)
+          trace.endpoint = controller_action(payload)
+          [ CAT, trace.endpoint, nil, normalize_payload(payload) ]
+        end
+
+      private
+
+        def controller_action(payload)
+          "#{payload[:controller]}##{payload[:action]}"
+        end
+
+        def normalize_payload(payload)
+          normalized = {}
+
+          PAYLOAD_KEYS.each do |key|
+            val = payload[key]
+            val = val.inspect unless val.is_a?(String) || val.is_a?(Numeric)
+            normalized[key] = val
+          end
+
+          normalized
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_controller/send_file.rb

@@ -0,0 +1,76 @@
+module Skylight
+  module Normalizers
+    module ActionController
+
+      # Temporary hacks
+      begin
+        require "action_dispatch/http/mime_type"
+        require "action_dispatch/http/mime_types"
+        require "rack/utils"
+
+        class SendFile < Normalizer
+          register "send_file.action_controller"
+
+          CAT = "app.controller.send_file".freeze
+          TITLE = "send file".freeze
+
+          def normalize(trace, name, payload)
+            path = payload[:path]
+
+            annotations = {
+              path:        path,
+              filename:    payload[:filename],
+              type:        normalize_type(payload),
+              disposition: normalize_disposition(payload),
+              status:      normalize_status(payload) }
+
+            title = TITLE
+
+            # depending on normalization, we probably want this to eventually
+            # include the full path, but we need to make sure we have a good
+            # deduping strategy first.
+            desc = nil
+
+            [ CAT, title, desc, annotations ]
+          end
+
+        private
+
+          OCTET_STREAM = "application/octet-stream".freeze
+          ATTACHMENT = "attachment".freeze
+
+          def initialize(*)
+            super
+
+            @mimes = Mime::SET.reduce({}) do |hash, mime|
+              hash[mime.symbol] = mime.to_s.dup.freeze
+              hash
+            end
+          end
+
+          def normalize_type(payload)
+            type = payload[:type] || OCTET_STREAM
+            type = @mimes[type] if type.is_a?(Symbol)
+            type
+          end
+
+          def mime_for(type)
+            @mimes[type] ||= Mime[type].to_s.freeze
+          end
+
+          def normalize_status(payload)
+            status = payload[:status] || 200
+            Rack::Utils.status_code(status)
+          end
+
+          def normalize_disposition(payload)
+            payload[:disposition] || ATTACHMENT
+          end
+        end
+
+      rescue LoadError
+      end
+
+    end
+  end
+end

data/lib/skylight/normalizers/action_view/render_collection.rb

@@ -0,0 +1,18 @@
+module Skylight
+  module Normalizers
+    module ActionView
+      class RenderCollection < RenderNormalizer
+        register "render_collection.action_view"
+
+        CAT = "view.render.collection".freeze
+
+        def normalize(trace, name, payload)
+          normalize_render(
+            CAT,
+            payload,
+            count: payload[:count])
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_view/render_partial.rb

@@ -0,0 +1,18 @@
+module Skylight
+  module Normalizers
+    module ActionView
+      class RenderPartial < RenderNormalizer
+        register "render_partial.action_view"
+
+        CAT = "view.render.template".freeze
+
+        def normalize(trace, name, payload)
+          normalize_render(
+            CAT,
+            payload,
+            partial: 1)
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/action_view/render_template.rb

@@ -0,0 +1,18 @@
+module Skylight
+  module Normalizers
+    module ActionView
+      class RenderTemplate < RenderNormalizer
+        register "render_template.action_view"
+
+        CAT = "view.render.template".freeze
+
+        def normalize(trace, name, payload)
+          normalize_render(
+            CAT,
+            payload,
+            partial: 0)
+        end
+      end
+    end
+  end
+end