app_perf_rpm 0.0.2

data/lib/app_perf_rpm/instruments/typhoeus.rb

@@ -0,0 +1,55 @@
+module AppPerfRpm
+  module Instruments
+    module TyphoeusRequest
+      def run_with_trace
+        if ::AppPerfRpm.tracing?
+          span = ::AppPerfRpm::Tracer.start_span("typhoeus")
+          response = run_without_trace
+          span.finish
+
+          uri = URI(response.effective_url)
+
+          span.options = {
+            "http_status" => response.code,
+            "remote_url" => uri.to_s,
+            "http_method" => options[:method]
+          }
+          span.submit(opts)
+
+          response
+        else
+          run_without_trace
+        end
+      end
+    end
+
+    module TyphoeusHydra
+      def run_with_trace
+        ::AppPerfRpm::Tracer.trace("typhoeus") do |span|
+          span.options = {
+            "method" => :hydra,
+            "queued_requests" => queued_requests.count,
+            "max_concurrency" => max_concurrency
+          }
+          run_without_trace
+        end
+      end
+    end
+  end
+end
+
+if ::AppPerfRpm.configuration.instrumentation[:typhoeus][:enabled] && defined?(::Typhoeus)
+  ::AppPerfRpm.logger.info "Initializing typhoeus tracer."
+
+  ::Typhoeus::Request::Operations.send(:include, AppPerfRpm::Instruments::TyphoeusRequest)
+  ::Typhoeus::Request::Operations.class_eval do
+    alias_method :run_without_trace, :run
+    alias_method :run, :run_with_trace
+  end
+
+  ::Typhoeus::Hydra.send(:include, AppPerfRpm::Instruments::TyphoeusHydra)
+  ::Typhoeus::Hydra.class_eval do
+    alias_method :run_without_trace, :run
+    alias_method :run, :run_with_trace
+  end
+end

data/lib/app_perf_rpm/introspector.rb

@@ -0,0 +1,51 @@
+module AppPerfRpm
+  class Introspector
+
+    VALID_RUNNERS = [
+      :Passenger,
+      :Puma,
+      :Rainbows,
+      :Resque,
+      :Sidekiq,
+      :Sinatra,
+      :Unicorn,
+      :Webrick
+    ]
+    class << self
+
+      def agentable?
+        if raking? || rspecing?
+          AppPerfRpm.logger.info("Detected rake, not initializing agent")
+          return false
+        end
+        AppPerfRpm.logger.info("Detecting runner...")
+        VALID_RUNNERS.each do |runner|
+          if const_defined?(runner.to_s)
+            AppPerfRpm.logger.info("#{runner} detected. You're valid")
+            return true
+          end
+        end
+        AppPerfRpm.logger.info("No valid runner detected!")
+        false
+      end
+
+      def rspecing?
+        (File.basename($0) =~ /\Arspec/) == 0
+      end
+
+      def raking?
+        (File.basename($0) =~ /\Arake/) == 0
+      end
+
+      def const_defined?(string_const)
+        begin
+        Object.const_get(string_const)
+          true
+        rescue NameError
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/app_perf_rpm/logger.rb

@@ -0,0 +1,32 @@
+require 'logger'
+
+module AppPerfRpm
+  class << self
+    attr_accessor :logger
+  end
+
+  class Logger
+    def info(msg)
+      AppPerfRpm.info(msg)
+    end
+
+    def debug(msg)
+      AppPerfRpm.info(msg)
+    end
+
+    def warn(msg)
+      AppPerfRpm.info(msg)
+    end
+
+    def error(msg)
+      AppPerfRpm.info(msg)
+    end
+
+    def fatal(msg)
+      AppPerfRpm.info(msg)
+    end
+  end
+end
+
+AppPerfRpm.logger = Logger.new(STDERR)
+AppPerfRpm.logger.level = Logger::INFO

data/lib/app_perf_rpm/middleware.rb

@@ -0,0 +1,30 @@
+module AppPerfRpm
+  class Middleware
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        @status, @headers, @response = @app.call(env)
+      rescue Exception => e
+        handle_exception(env, e)
+      end
+      [@status, @headers, @response]
+    end
+
+    def handle_exception(env, exception)
+      ::AppPerfRpm::Tracer.log_event("error",
+        "path" => env["PATH_INFO"],
+        "method" => env["REQUEST_METHOD"],
+        "message" => exception.message,
+        "error_class" => exception.class.to_s,
+        "backtrace" => ::AppPerfRpm::Backtrace.clean(exception.backtrace),
+        "source" => ::AppPerfRpm::Backtrace.source_extract(exception.backtrace)
+      )
+      raise exception
+    end
+  end
+end

data/lib/app_perf_rpm/rails.rb

@@ -0,0 +1,14 @@
+if defined?(::Rails)
+  if ::Rails::VERSION::MAJOR > 2
+    require 'app_perf_rpm/railtie'
+  else
+    Rails.configuration.after_initialize do
+      unless AppPerfRpm.disable_agent?
+        AppPerfRpm.load
+        Rails.configuration.middleware.use AppPerfRpm::Middleware
+        AppPerfRpm.logger.info "Initializing rack middleware tracer."
+        Rails.configuration.middleware.insert 0, AppPerfRpm::Instruments::Rack
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/railtie.rb

@@ -0,0 +1,29 @@
+module AppPerfRpm
+  class Railtie < ::Rails::Railtie
+    require 'app_perf_rpm/instruments/rack'
+
+    # TODO: Why this isn't working with the initializer?
+    initializer "app_perf.initialize" do |app|
+      unless AppPerfRpm.disable_agent?
+        app.middleware.use AppPerfRpm::Middleware
+
+        if ::AppPerfRpm.configuration.instrumentation[:rack][:enabled]
+          AppPerfRpm.logger.info "Initializing rack tracer."
+          app.middleware.insert 0, AppPerfRpm::Instruments::Rack
+
+          if AppPerfRpm.configuration.instrumentation[:rack][:trace_middleware]
+            AppPerfRpm.logger.info "Initializing rack middleware tracer."
+            require 'app_perf_rpm/instruments/rack_middleware'
+            app.middleware.insert 1, AppPerfRpm::Instruments::RackMiddleware
+          end
+        end
+      end
+
+      config.after_initialize do
+        AppPerfRpm.configuration.app_root = Rails.root
+        AppPerfRpm.configuration.reload
+        AppPerfRpm.load
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/span.rb

@@ -0,0 +1,103 @@
+module AppPerfRpm
+  class Span
+    attr_accessor :layer,
+                  :controller,
+                  :action,
+                  :url,
+                  :domain,
+                  :type,
+                  :backtrace,
+                  :source,
+                  :trace_id,
+                  :started_at,
+                  :ended_at,
+                  :children,
+                  :options
+
+    def self.arrange(spans)
+      spans.sort! { |a, b| (a.ended_at <=> b.ended_at) }
+
+      null_span = Span.new
+      controller = (spans.find {|s| s.controller } || null_span).controller
+      action = (spans.find {|s| s.action } || null_span).action
+      domain = (spans.find {|s| s.domain } || null_span).domain
+      url = (spans.find {|s| s.url } || null_span).url
+
+      while span = spans.shift
+        span.controller ||= controller
+        span.action ||= action
+        span.domain ||= domain
+        span.url ||= url
+
+        if parent = spans.find { |n| n.parent_of?(span) }
+          parent.children << span
+        elsif spans.empty?
+          root = span
+        end
+      end
+
+      root
+    end
+
+    def initialize
+      self.children = []
+      self.type = "web"
+      self.options = {}
+    end
+
+    def duration
+      @duration ||= (ended_at - started_at) * 1000.0
+    end
+
+    def exclusive_duration
+      @exclusive_duration ||= duration - children.inject(0.0) { |sum, child| sum + child.duration }
+    end
+
+    def parent_of?(span)
+      start = (started_at - span.started_at) * 1000.0
+      start <= 0 && (start + duration >= span.duration)
+    end
+
+    def child_of?(span)
+      span.parent_of?(self)
+    end
+
+    def to_spans
+      span = self.dup
+      span.exclusive_duration
+      span.children = []
+
+      if children.size > 0
+        return [span] + children.map(&:to_spans)
+      else
+        return [span]
+      end
+    end
+
+    def base_options
+      opts = {}
+      opts["domain"] = domain
+      opts["controller"] = controller
+      opts["action"] =  action
+      opts["url"] = url
+      opts["type"] = type
+      #opts["backtrace"] = ::AppPerfRpm::Backtrace.backtrace
+      opts["source"] = ::AppPerfRpm::Backtrace.source_extract
+      opts.delete_if { |k, v| v.nil? }
+    end
+
+    def to_s
+      "#{layer}:#{trace_id}:#{started_at}:#{exclusive_duration}"
+    end
+
+    def to_a
+      [
+        layer,
+        trace_id,
+        started_at,
+        duration,
+        base_options.merge(options)
+      ]
+    end
+  end
+end

data/lib/app_perf_rpm/tracer.rb

@@ -0,0 +1,139 @@
+module AppPerfRpm
+  class Tracer
+    class << self
+      def trace_id
+        Thread.current[:trace_id]
+      end
+
+      def trace_id=(t)
+        Thread.current[:trace_id] = t
+      end
+
+      def tracing?
+        Thread.current[:trace_id]
+      end
+
+      def in_trace?
+        !Thread.current[:trace_id].nil?
+      end
+
+      def start_span(layer, opts = {})
+        Instance.new(layer, opts)
+      end
+
+      def random_percentage
+        rand * 100
+      end
+
+      def should_trace?
+        random_percentage < ::AppPerfRpm.configuration.sample_rate.to_i
+      end
+
+      def start_trace(layer, opts = {})
+        start = Time.now.to_f
+
+        trace_id = opts.delete("trace_id")
+        if trace_id || should_trace?
+          self.trace_id = trace_id || generate_trace_id
+          result = trace(layer, opts) do |span|
+            yield(span)
+          end
+          self.trace_id = nil
+        else
+          result = yield
+        end
+
+        return result, (Time.now.to_f - start) * 1000
+      end
+
+      def trace(layer, opts = {})
+        result = nil
+
+        if tracing?
+          span = Span.new
+          span.layer = layer
+          span.trace_id = self.trace_id
+          span.started_at = Time.now.to_f
+          result = yield(span)
+          span.ended_at = Time.now.to_f
+          span.options.merge!(opts)
+          ::AppPerfRpm.store(span)
+        else
+          result = yield
+        end
+
+        result
+      end
+
+      def profile(layer, opts = {})
+        if defined?(TracePoint)
+          @times = {}
+          traces = []
+          tracer = TracePoint.new(:call, :return) do |tp|
+            backtrace = caller(0)
+            key = "#{tp.defined_class}_#{tp.method_id}_#{backtrace.size}"
+            if tp.event == :call
+              @times[key] = Time.now.to_f
+            else
+              if @times[key]
+                @times[key] = Time.now.to_f - @times[key].to_f
+                traces << {
+                  "duration "=> @times[key].to_f,
+                  "class" => tp.defined_class,
+                  "method" => tp.method_id,
+                  "backtrace" => backtrace,
+                  "line" => ::AppPerfRpm::Backtrace.send(:clean_line, tp.path),
+                  "line_number" => tp.lineno
+                }
+              end
+            end
+          end
+
+          result = tracer.enable { yield }
+          @times = {}
+
+          return traces, result
+        else
+          return [], yield
+        end
+      end
+
+      def log_event(event, opts = {})
+        ::AppPerfRpm.store([event, generate_trace_id, Time.now.to_f, opts])
+      end
+
+      def generate_trace_id
+        Digest::SHA1.hexdigest([Time.now, rand].join)
+      end
+
+      class Instance
+        attr_accessor :layer, :opts, :start, :duration
+
+        def initialize(layer, opts = {})
+          @span = Span.new
+          @span.layer = layer
+          @span.options = opts
+          @span.started_at = Time.now.to_f
+        end
+
+        def finish(opts = {})
+          @span.options.merge!(opts)
+          @span.ended_at = Time.now.to_f
+        end
+
+        def submit(opts = {})
+          if ::AppPerfRpm::Tracer.tracing?
+            @span.options.merge!(opts)
+            ::AppPerfRpm.store(@span)
+          end
+        end
+
+        private
+
+        def trace_id
+          ::AppPerfRpm::Tracer.trace_id
+        end
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/utils.rb

@@ -0,0 +1,9 @@
+module AppPerfRpm
+  module Utils
+    REGEXP ||= Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)')
+
+    def sanitize_sql(sql, adapter)
+      sql.gsub(REGEXP, '?')
+    end
+  end
+end

data/lib/app_perf_rpm/worker.rb

@@ -0,0 +1,46 @@
+module AppPerfRpm
+  class Worker
+    def initialize
+      AppPerfRpm.logger.info "Starting worker."
+      @dispatcher = Dispatcher.new
+    end
+
+    def save(event)
+      start
+      return if event.nil?
+      @dispatcher.add_event(event)
+    end
+
+    def start
+      return if worker_running?
+      ::AppPerfRpm.mutex.synchronize do
+        return if worker_running?
+        start_dispatcher
+        ::AppPerfRpm.logger.info "Worker is running."
+      end
+    end
+
+    def worker_running?
+      @worker_thread && @worker_thread.alive?
+    end
+
+    def start_dispatcher
+      @worker_thread = Thread.new do
+        ::AppPerfRpm.configuration.reload
+        @dispatcher.reset
+
+        loop do
+          start = Time.now
+          if @dispatcher.ready?
+            @dispatcher.dispatch
+            @dispatcher.reset
+          end
+          sleep_for = (start + 15 - Time.now)
+          sleep_for = 1 if sleep_for < 1
+          sleep sleep_for
+        end
+      end
+      @worker_thread.abort_on_exception = true
+    end
+  end
+end

data/lib/app_perf_rpm.rb

@@ -0,0 +1,124 @@
+require 'oj'
+
+module AppPerfRpm
+  require 'app_perf_rpm/logger'
+  require 'app_perf_rpm/configuration'
+  require 'app_perf_rpm/span'
+  require 'app_perf_rpm/aggregator'
+  require 'app_perf_rpm/dispatcher'
+  require 'app_perf_rpm/worker'
+  require 'app_perf_rpm/backtrace'
+  require 'app_perf_rpm/tracer'
+  require 'app_perf_rpm/utils'
+  require 'app_perf_rpm/middleware'
+  require 'app_perf_rpm/instrumentation'
+  require 'app_perf_rpm/rails'
+  require 'app_perf_rpm/introspector'
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def load
+      #Oj.mimic_JSON
+      unless disable_agent?
+        AppPerfRpm::Instrumentation.load
+        @worker = ::AppPerfRpm::Worker.new
+
+        if @worker.start
+          @worker_running = true
+          AppPerfRpm.tracing_on
+        end
+      end
+    end
+
+    def worker
+      @worker
+    end
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+    def store(event)
+      if @worker_running && tracing?
+        @worker.save(event)
+      end
+      event
+    end
+
+    def tracing_on
+      if @without_tracing_enabled
+        AppPerfRpm.logger.debug "Not turning tracing on due to without tracing mode."
+        return
+      end
+      mutex.synchronize do
+        AppPerfRpm.logger.debug "Enabling tracing."
+        @tracing = true
+      end
+    end
+
+    def tracing_off
+      mutex.synchronize do
+        AppPerfRpm.logger.debug "Disabling tracing."
+        @tracing = false
+      end
+    end
+
+    def tracing?
+      @tracing
+    end
+
+    def without_tracing
+      @previously_tracing = AppPerfRpm.tracing?
+      @without_tracing_enabled = true
+      AppPerfRpm.tracing_off
+      yield if block_given?
+      @without_tracing_enabled = false
+    ensure
+      AppPerfRpm.tracing_on if @previously_tracing
+    end
+
+    def host
+      @host ||= Socket.gethostname
+    end
+
+    def round_time(t, sec = 1)
+      t = Time.parse(t.to_s)
+
+      down = t - (t.to_i % sec)
+      up = down + sec
+
+      difference_down = t - down
+      difference_up = up - t
+
+      if (difference_down < difference_up)
+        return down
+      else
+        return up
+      end
+    end
+
+    def floor_time(t, sec = 1)
+      Time.at((t.to_f / sec).floor * sec)
+    end
+
+    def disable_agent?
+      if configuration.agent_disabled
+        true
+      elsif Introspector.agentable?
+        false
+      else
+        true
+      end
+    end
+
+  end
+end

data/lib/tasks/install.rake

@@ -0,0 +1,6 @@
+namespace :app_perf do
+  desc "Install app_perf_ruby_agent.yml file"
+  task :install do
+    load File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "install.rb"))
+  end
+end