stackify-ruby-apm 0.9.0

data/lib/stackify/spies/action_dispatch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# This module monkey patches usually in Exceptions class
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class ActionDispatchSpy
+      def install
+        ::ActionDispatch::ShowExceptions.class_eval do
+          alias render_exception_without_apm render_exception
+
+          def render_exception(env, exception)
+            StackifyRubyAPM.report(exception)
+            render_exception_without_apm env, exception
+          end
+        end
+      end
+    end
+
+    register(
+      'ActionDispatch::ShowExceptions',
+      'action_dispatch/show_exception',
+      ActionDispatchSpy.new
+    )
+  end
+end

data/lib/stackify/spies/httpclient.rb

@@ -0,0 +1,47 @@
+require 'stackify/log'
+require 'stackify/logger'
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class HTTPClientSpy
+      include Log
+
+      # This class monkeypatches the HTTPClient class with request method.
+      def install
+        HTTPClient.class_eval do
+          alias request_without_apm request
+
+          def request(method, uri, *args, &block)
+            req = nil
+            unless StackifyRubyAPM.current_transaction
+              return request_without_apm(method, uri, *args, &block)
+            end
+            method = method.upcase
+            uri = uri.strip
+            name = "#{method} #{uri}"
+            type = "ext.httpclient.#{method}"
+
+            req = request_without_apm(method, uri, *args, &block)
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: uri,
+              STATUS: req.status_code,
+              METHOD: method
+            )
+
+            StackifyRubyAPM.span name, type, context: ctx do
+              req
+            end
+
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'HTTPClient', 'httpclient', HTTPClientSpy.new
+  end
+end

data/lib/stackify/spies/mongo.rb

@@ -0,0 +1,66 @@
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    # This class monkeypatch the Mongo::Monitoring::Global module in mongoDB(http://api.mongodb.com/ruby/current/Mongo/Monitoring/Global.html)
+    class MongoSpy
+      def install
+        ::Mongo::Monitoring::Global.subscribe(
+          ::Mongo::Monitoring::COMMAND,
+          Subscriber.new
+        )
+      end
+
+      # @api private
+      class Subscriber
+        TYPE = 'db.mongodb.query'.freeze
+
+        def initialize
+          @events = {}
+        end
+
+        def started(event)
+          push_event(event)
+        end
+
+        def failed(event)
+          pop_event(event)
+        end
+
+        def succeeded(event)
+          pop_event(event)
+        end
+
+        private
+
+        def push_event(event)
+          return unless StackifyRubyAPM.current_transaction
+
+          document = event.command.find
+          col = nil
+          if document
+            document.each_with_index do |val, idx|
+              col = val[1] if idx == 0
+            end
+          end
+
+          ctx = Span::Context.new(
+            CATEGORY: 'MongoDB',
+            MONGODB_COLLECTION: col,
+          )
+          span = StackifyRubyAPM.span(event.command_name, TYPE, context: ctx)
+          @events[event.operation_id] = span
+        end
+
+        def pop_event(event)
+          return unless StackifyRubyAPM.current_transaction
+
+          span = @events.delete(event.operation_id)
+          span && span.done
+        end
+      end
+    end
+
+    register 'Mongo', 'mongo', MongoSpy.new
+  end
+end

data/lib/stackify/spies/net_http.rb

@@ -0,0 +1,47 @@
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class NetHTTPSpy
+      # This class monkeypatch the Net::HTTP class with request method.
+      def install
+        Net::HTTP.class_eval do
+          alias request_without_apm request
+
+          def request(req, body = nil, &block)
+            result = nil
+            unless StackifyRubyAPM.current_transaction
+              request_without_apm(req, body, &block)
+            end
+
+            host, = req['host'] && req['host'].split(':')
+            method = req.method
+
+            host ||= address
+
+            name = "#{method} #{host}"
+            type = "ext.net_http.#{method}"
+
+            result = request_without_apm(req, body, &block)
+
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: req.uri,
+              STATUS: result.code.to_i,
+              METHOD: method
+            )
+
+            StackifyRubyAPM.span name, type, context: ctx do
+              return result
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+    
+
+    register 'Net::HTTP', 'net/http', NetHTTPSpy.new
+  end
+end

data/lib/stackify/spies/sinatra.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+#
+# Monkey patch for the Sinatra::Base class which is responsible for handling requests.
+#
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class SinatraSpy
+      # rubocop:disable Metrics/MethodLength
+      def install
+        ::Sinatra::Base.class_eval do
+          alias dispatch_without_apm! dispatch!
+          alias compile_template_without_apm compile_template
+
+          # Sets transaction name from Sinatra env's route name 
+          #
+          def dispatch!(*args, &block)
+            dispatch_without_apm!(*args, &block).tap do
+              next unless (transaction = StackifyRubyAPM.current_transaction)
+              next unless (route = env['sinatra.route'])
+
+              transaction.name = route
+            end
+          end
+
+          # Tilt engine templating 
+          #
+          def compile_template(engine, data, opts, *args, &block)
+            opts[:__stackify_apm_template_name] =
+              case data
+              when Symbol then data.to_s
+              else format('Inline %s', engine)
+              end
+
+            compile_template_without_apm(engine, data, opts, *args, &block)
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    # Registers Sinatra spy, go to: /stackify/spies.rb
+    #
+    register 'Sinatra::Base', 'sinatra/base', SinatraSpy.new
+
+    require 'stackify/spies/tilt'
+  end
+end

data/lib/stackify/spies/tilt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class TiltSpy
+      # This class monkeypatch the Tilt::Template class with render method.
+      TYPE = 'template.tilt'.freeze
+
+      def install
+        ::Tilt::Template.class_eval do
+          alias render_without_apm render
+
+          def render(*args, &block)
+            name = options[:__stackify_apm_template_name] || 'Unknown template'
+
+            StackifyRubyAPM.span name, TYPE do
+              render_without_apm(*args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    register 'Tilt::Template', 'tilt/template', TiltSpy.new
+  end
+end

data/lib/stackify/stacktrace.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+#
+# This module starts creation for frames
+#
+module StackifyRubyAPM
+    # @api private
+    class Stacktrace
+      attr_accessor :frames
+  
+      def length
+        frames.length
+      end
+  
+      def to_a
+        frames.map(&:to_h)
+      end
+    end
+  end
+  

data/lib/stackify/stacktrace/frame.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+    class Stacktrace
+      # @api private
+      class Frame
+        include NaivelyHashable
+  
+        attr_accessor(
+          :abs_path,
+          :filename,
+          :function,
+          :vars,
+          :pre_context,
+          :context_line,
+          :post_context,
+          :library_frame,
+          :lineno,
+          :module,
+          :Method,
+          :colno
+        )
+  
+        # rubocop:disable Metrics/AbcSize
+        def build_context(context_line_count)
+          return unless abs_path && context_line_count > 0
+  
+          padding = (context_line_count - 1) / 2
+          from = lineno - padding - 1
+          from = 0 if from < 0
+          to = lineno + padding - 1
+          file_lines = read_lines(abs_path, from..to)
+  
+          self.context_line = file_lines[padding]
+          self.pre_context  = file_lines.first(padding)
+          self.post_context = file_lines.last(padding)
+        end
+        # rubocop:enable Metrics/AbcSize
+  
+        private
+  
+        def read_lines(path, range)
+          File.readlines(path)[range]
+        rescue Errno::ENOENT
+          []
+        end
+      end
+    end
+  end
+  

data/lib/stackify/stacktrace_builder.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+#
+# This module gathers the lists of frames and build them into hash format
+#
+require 'stackify/stacktrace/frame'
+require 'stackify/util/lru_cache'
+
+module StackifyRubyAPM
+  # @api private
+  class StacktraceBuilder
+    JAVA_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/
+    RUBY_FORMAT = /^(.+?):(\d+)(?::in `(.+?)')?$/
+
+    RUBY_VERS_REGEX = %r{ruby(/gems)?[-/](\d+\.)+\d}
+    JRUBY_ORG_REGEX = %r{org/jruby}
+
+    def initialize(agent)
+      @config = agent.config
+      @cache = Util::LruCache.new(2048, &method(:build_frame))
+    end
+
+    attr_reader :config
+
+    def build(backtrace, type:)
+      Stacktrace.new.tap do |s|
+        s.frames = backtrace.map do |line|
+          @cache[[line, type]]
+        end
+      end
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def build_frame(cache, keys)
+      line, type = keys
+      abs_path, lineno, function, _module_name = parse_line(line)
+      current_filename = strip_load_path(abs_path)
+
+      frame = Stacktrace::Frame.new
+      #frame.abs_path = abs_path
+      #frame.filename = strip_load_path(abs_path)
+      frame.Method =  "#{function} (#{current_filename}:#{lineno})"
+      #frame.lineno = lineno.to_i
+      #frame.library_frame = library_frame?(config, abs_path)
+
+      line_count =
+        context_lines_for(config, type, library_frame: frame.library_frame)
+      frame.build_context line_count
+
+      cache[[line, type]] = frame
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def parse_line(line)
+      ruby_match = line.match(RUBY_FORMAT)
+
+      if ruby_match
+        _, file, number, method = ruby_match.to_a
+        file.sub!(/\.class$/, '.rb')
+        module_name = nil
+      else
+        java_match = line.match(JAVA_FORMAT)
+        _, module_name, method, file, number = java_match.to_a
+      end
+
+      [file, number, method, module_name]
+    end
+
+    def library_frame?(config, abs_path)
+      return false unless abs_path
+
+      if abs_path.start_with?(config.root_path)
+        return true if abs_path.start_with?(config.root_path + '/vendor')
+        return false
+      end
+
+      return true if abs_path.match(RUBY_VERS_REGEX)
+      return true if abs_path.match(JRUBY_ORG_REGEX)
+
+      false
+    end
+
+    def strip_load_path(path)
+      return nil if path.nil?
+
+      prefix =
+        $LOAD_PATH
+        .map(&:to_s)
+        .select { |s| path.start_with?(s) }
+        .max_by(&:length)
+
+      prefix ? path[prefix.chomp(File::SEPARATOR).length + 1..-1] : path
+    end
+
+    def context_lines_for(config, type, library_frame:)
+      key = "source_lines_#{type}_#{library_frame ? 'library' : 'app'}_frames"
+      config.send(key.to_sym)
+    end
+  end
+end