metrician 0.0.1

data/lib/metrician/reporters/active_record.rb

@@ -0,0 +1,63 @@
+module Metrician
+
+  class ActiveRecord < Reporter
+
+    def self.enabled?
+      !!defined?(::ActiveRecord) &&
+        Metrician.configuration[:database][:enabled]
+    end
+
+    def instrument
+      ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+        include QueryInterceptor
+      end
+    end
+
+  end
+
+  module QueryInterceptor
+
+    COMMAND_EXP = /^(select|update|insert|delete|show|begin|commit|rollback|describe)/i
+    SQL_EXP     = /#{COMMAND_EXP} (?:into |from |.+? from )?(?:[`"]([a-z_]+)[`"])?/i
+    OTHER       = "other".freeze
+
+    def self.included(instrumented_class)
+      return if instrumented_class.method_defined?(:log_without_metrician)
+      instrumented_class.class_eval do
+        alias_method :log_without_metrician, :log
+        alias_method :log, :log_with_metrician
+        protected :log
+      end
+    end
+
+    def log_with_metrician(*args, &block)
+      start_time = Time.now.to_f
+      sql, name, _binds = args
+      sql = sql.dup.force_encoding(Encoding::BINARY)
+      config = Metrician.configuration[:database]
+      metrics = []
+      metrics << "database.query" if config[:query][:enabled]
+      if config[:command] || config[:table]
+        command, table = parse_sql(sql)
+        metrics << "database.#{command}" if config[:command] && command
+        metrics << "database.#{table}" if config[:table] && table
+        metrics << "database.#{command}.#{table}" if config[:command] && config[:table] && command && table
+      end
+      begin
+        log_without_metrician(*args, &block)
+      ensure
+        duration = Time.now.to_f - start_time
+        metrics.each { |m| Metrician.gauge(m, duration) }
+      end
+    end
+
+    def parse_sql(sql)
+      match = sql.match(SQL_EXP)
+      command = (match && match[1].downcase) || OTHER
+      table = (match && match[2] && match[2].downcase)
+      [command, table]
+    end
+
+  end
+
+end

data/lib/metrician/reporters/delayed_job.rb

@@ -0,0 +1,17 @@
+module Metrician
+  class DelayedJob < Reporter
+
+    def self.enabled?
+      !!defined?(::Delayed::Worker) &&
+        Metrician::Jobs.enabled?
+    end
+
+    def instrument
+      require "metrician/jobs/delayed_job_callbacks"
+      unless ::Delayed::Worker.plugins.include?(::Metrician::Jobs::DelayedJobCallbacks)
+        ::Delayed::Worker.plugins << ::Metrician::Jobs::DelayedJobCallbacks
+      end
+    end
+
+  end
+end

data/lib/metrician/reporters/honeybadger.rb

@@ -0,0 +1,26 @@
+module Metrician
+  class Honeybadger < Reporter
+
+    def self.enabled?
+      !!defined?(::Honeybadger) &&
+        Metrician.configuration[:exception][:enabled]
+    end
+
+    def instrument
+      ::Honeybadger::Agent.class_eval do
+        def notify_with_metrician(exception, options = {})
+          # We can differentiate whether or not we live inside a web
+          # request or not by determining the nil-ness of:
+          #   context_manager.get_rack_env
+          notify_without_metrician(exception, options)
+        ensure
+          Metrician.increment("exception.raise") if Metrician.configuration[:exception][:raise][:enabled]
+          Metrician.increment("exception.raise.#{Metrician.dotify(exception.class.name.underscore)}") if exception && Metrician.configuration[:exception][:exception_specific][:enabled]
+        end
+        alias_method :notify_without_metrician, :notify
+        alias_method :notify, :notify_with_metrician
+      end
+    end
+
+  end
+end

data/lib/metrician/reporters/memcache.rb

@@ -0,0 +1,49 @@
+module Metrician
+  class Memcache < Reporter
+
+    METHODS = %i[get delete cas prepend append replace decrement increment add set].freeze
+
+    def self.memcached_gem?
+      !!defined?(::Memcached)
+    end
+
+    def self.dalli_gem?
+      !!defined?(::Dalli) && !!defined?(::Dalli::Client)
+    end
+
+    def client_class
+      if self.class.memcached_gem?
+        Memcached
+      elsif self.class.dalli_gem?
+        Dalli::Client
+      end
+    end
+
+    def self.enabled?
+      (memcached_gem? || dalli_gem?) &&
+        Metrician.configuration[:cache][:enabled]
+    end
+
+    def instrument
+      return if client_class.method_defined?(:get_with_metrician_trace)
+      METHODS.each do |method_name|
+        next unless client_class.method_defined?(method_name)
+        client_class.class_eval <<-EOD
+          def #{method_name}_with_metrician_trace(*args, &blk)
+            start_time = Time.now
+            begin
+              #{method_name}_without_metrician_trace(*args, &blk)
+            ensure
+              duration = (Time.now - start_time).to_f
+              Metrician.gauge("cache.command", duration) if Metrician.configuration[:cache][:command][:enabled]
+              Metrician.gauge("cache.command.#{method_name}", duration) if Metrician.configuration[:cache][:command_specific][:enabled]
+            end
+          end
+          alias #{method_name}_without_metrician_trace #{method_name}
+          alias #{method_name} #{method_name}_with_metrician_trace
+        EOD
+      end
+    end
+
+  end
+end

data/lib/metrician/reporters/method_tracer.rb

@@ -0,0 +1,70 @@
+module Metrician
+
+  class MethodTracer < Reporter
+
+    def self.enabled?
+      Metrician.configuration[:method_tracer][:enabled]
+    end
+
+    def instrument
+      Module.send(:include, TracingMethodInterceptor)
+    end
+
+  end
+
+  module TracingMethodInterceptor
+
+    def self.default_metric_name(klass, is_klass_method, method_name)
+      name = klass.name.underscore
+      name = "#{name}.self" if is_klass_method
+      "tracer.#{name}.#{method_name}".downcase.tr_s("^a-zA-Z0-9.", "_")
+    end
+
+    def self.traceable_method?(klass, method_name)
+      klass.method_defined?(method_name) ||
+        klass.private_method_defined?(method_name) ||
+        klass.methods.include?(method_name.to_s)
+    end
+
+    def self.already_traced_method?(klass, is_klass_method, traced_name)
+      is_klass_method ?
+        klass.methods.include?(traced_name) :
+        klass.method_defined?(traced_name)
+    end
+
+    def self.code_to_eval(is_klass_method, method_name, traced_name, untraced_name, metric_name)
+      <<-EOD
+        #{'class << self' if is_klass_method}
+        def #{traced_name}(*args, &block)
+          start_time = Time.now
+          begin
+            #{untraced_name}(*args, &block)
+          ensure
+            Metrician.gauge("#{metric_name}", (Time.now - start_time).to_f)
+          end
+        end
+        alias :#{untraced_name} :#{method_name}
+        alias :#{method_name} :#{traced_name}
+        #{'end' if is_klass_method}
+      EOD
+    end
+
+    def add_metrician_method_tracer(method_name, metric_name = nil)
+      return false unless TracingMethodInterceptor.traceable_method?(self, method_name)
+
+      is_klass_method = methods.include?(method_name.to_s)
+      traced_name = "with_metrician_trace_#{method_name}"
+      return false if TracingMethodInterceptor.already_traced_method?(self, is_klass_method, traced_name)
+
+      metric_name ||= TracingMethodInterceptor.default_metric_name(self, is_klass_method, method_name)
+      untraced_name = "without_metrician_trace_#{method_name}"
+
+      traced_method_code =
+        TracingMethodInterceptor.code_to_eval(is_klass_method, method_name, traced_name,
+                                              untraced_name, metric_name)
+      class_eval(traced_method_code, __FILE__, __LINE__)
+    end
+
+  end
+
+end

data/lib/metrician/reporters/middleware.rb

@@ -0,0 +1,22 @@
+module Metrician
+  module Reporters
+    class Middleware < Reporter
+      def self.enabled?
+        defined?(Rails) &&
+          Metrician::Middleware.enabled?
+      end
+
+      def instrument
+        require "metrician/middleware/request_timing"
+        require "metrician/middleware/application_timing"
+
+        app = Rails.application
+        return if app.nil?
+
+        app.middleware.insert_before(0, Metrician::Middleware::RequestTiming)
+        app.middleware.insert_after(Metrician::Middleware::RequestTiming, Rack::ContentLength)
+        app.middleware.use(Metrician::Middleware::ApplicationTiming)
+      end
+    end
+  end
+end

data/lib/metrician/reporters/net_http.rb

@@ -0,0 +1,28 @@
+require "net/http"
+
+module Metrician
+  class NetHttp < Reporter
+
+    def self.enabled?
+      !!defined?(Net::HTTP) &&
+        Metrician.configuration[:external_service][:enabled]
+    end
+
+    def instrument
+      return if ::Net::HTTP.method_defined?(:request_with_metrician_trace)
+      ::Net::HTTP.class_eval do
+        def request_with_metrician_trace(req, body = nil, &block)
+          start_time = Time.now
+          begin
+            request_without_metrician_trace(req, body, &block)
+          ensure
+            Metrician.gauge("service.request", (Time.now - start_time).to_f) if Metrician.configuration[:external_service][:request][:enabled]
+          end
+        end
+        alias_method :request_without_metrician_trace, :request
+        alias_method :request, :request_with_metrician_trace
+      end
+    end
+
+  end
+end

data/lib/metrician/reporters/redis.rb

@@ -0,0 +1,31 @@
+module Metrician
+  class Redis < Reporter
+
+    def self.enabled?
+      !!defined?(::Redis) &&
+        Metrician.configuration[:cache][:enabled]
+    end
+
+    def instrument
+      return if ::Redis::Client.method_defined?(:call_with_metrician_trace)
+      ::Redis::Client.class_eval do
+        def call_with_metrician_trace(*args, &blk)
+          start_time = Time.now
+          begin
+            call_without_metrician_trace(*args, &blk)
+          ensure
+            duration = (Time.now - start_time).to_f
+            Metrician.gauge("cache.command", duration) if Metrician.configuration[:cache][:command][:enabled]
+            if Metrician.configuration[:cache][:command_specific][:enabled]
+              method_name = args[0].is_a?(Array) ? args[0][0] : args[0]
+              Metrician.gauge("cache.command.#{method_name}", duration)
+            end
+          end
+        end
+        alias_method :call_without_metrician_trace, :call
+        alias_method :call, :call_with_metrician_trace
+      end
+    end
+
+  end
+end

data/lib/metrician/reporters/resque.rb

@@ -0,0 +1,17 @@
+module Metrician
+  class Resque < Reporter
+
+    def self.enabled?
+      !!defined?(::Resque) &&
+        Metrician::Jobs.enabled?
+    end
+
+    def instrument
+      require "metrician/jobs/resque_plugin"
+      unless ::Resque::Job.respond_to?(:around_perform_with_metrician)
+        ::Resque::Job.send(:extend, Metrician::Jobs::ResquePlugin)
+      end
+    end
+
+  end
+end

data/lib/metrician/reporters/sidekiq.rb

@@ -0,0 +1,19 @@
+module Metrician
+  class Sidekiq < Reporter
+
+    def self.enabled?
+      !!defined?(::Sidekiq) &&
+        Metrician::Jobs.enabled?
+    end
+
+    def instrument
+      require "metrician/jobs/sidekiq_middleware"
+      ::Sidekiq.configure_server do |config|
+        config.server_middleware do |chain|
+          chain.add ::Metrician::Jobs::SidekiqMiddleware
+        end
+      end
+    end
+
+  end
+end

data/lib/metrician/version.rb

@@ -0,0 +1,5 @@
+module Metrician
+
+  VERSION = "0.0.1".freeze
+
+end

data/metrician.gemspec

@@ -0,0 +1,25 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "metrician/version"
+
+Gem::Specification.new do |s|
+  s.name        = "metrician"
+  s.version     = Metrician::VERSION
+  s.authors     = ["Expected Behavior"]
+  s.email       = ["support@instrumentalapp.com"]
+  s.homepage    = "http://instrumentalapp.com/"
+  s.summary     = "Automatic Application Metric Collection for Ruby Applications"
+  s.description = "Automatically report the most important metrics about your ruby application, from request timing to job execution."
+  s.license     = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = %w[lib app]
+
+  s.add_development_dependency("instrumental_agent", "~> 0")
+  s.add_development_dependency("rubocop", "~> 0")
+  s.add_development_dependency("bundler", "~> 1.14")
+  s.add_development_dependency("rake", "~> 10.0")
+  s.add_development_dependency("rspec", "~> 3.0")
+  s.add_development_dependency("byebug", "~> 0")
+end

data/script/setup

@@ -0,0 +1,72 @@
+#!/bin/bash
+set -e
+cd "$(dirname "$0")/.."
+HOMEBREW_PREFIX=$(brew --config | grep HOMEBREW_PREFIX | sed 's/HOMEBREW_PREFIX: //')
+
+brew list redis > /dev/null 2>&1 || (
+  brew install redis
+  brew services restart redis
+)
+
+brew list mysql > /dev/null 2>&1 || (
+  brew install mysql
+  brew services start mysql
+)
+
+brew list postgresql > /dev/null 2>&1 || brew install postgresql
+
+# TODO: Install all rubies in .travis
+rbenv which ruby >/dev/null 2>&1 || (brew upgrade ruby-build || true; rbenv install)
+
+# Setup rbenv so we can switch rubies below
+eval "$(rbenv init - --no-rehash)"
+
+if [ ! -e Gemfile ]; then
+  tput bold    # bold text
+  tput setaf 2 # red text
+  echo "Gemfile symlink is broken. Should point to a known good Gemfile-x variant in ./gemfiles"
+  tput sgr0    # reset to default text
+  exit 199
+elif [ ! -e Gemfile.lock ]; then
+  tput bold    # bold text
+  tput setaf 2 # red text
+  echo "Gemfile.lock symlink is broken. Should point to a known good Gemfile-x.lock variant in ./gemfiles"
+  tput sgr0    # reset to default text
+  exit 200
+fi
+
+for ruby_version in `ruby -ryaml -e 'puts YAML.load(File.read(".travis.yml"))["rvm"].join(" ")'`; do
+  rbenv versions --bare | grep "^${ruby_version}$" || rbenv install $ruby_version
+  rbenv shell $ruby_version
+
+  gem list -i bundler >/dev/null || gem install bundler
+
+  gem list -i gemika >/dev/null || gem install gemika
+
+  rake matrix:install
+done
+
+if ! psql postgres -tc "SELECT 1 FROM pg_database WHERE datname = 'metrician_test'" | grep -q 1; then
+  psql -c 'create database metrician_test;' postgres
+fi
+mysql -e 'create database IF NOT EXISTS metrician_test;' -u root
+
+if [ ! -f spec/support/database.yml ]; then
+  tput bold    # bold text
+  tput setaf 2 # red text
+  echo "spec/support/database.yml doesn't exist, run:"
+  echo "  cp spec/support/database.sample.yml spec/support/database.yml"
+  echo
+  echo "and update the credentials to match your system"
+  tput sgr0    # reset to default text
+else
+  tput bold    # bold text
+  tput setaf 2 # green text
+  echo "****************************************************************"
+  echo "*                                                              *"
+  echo "*                         Good to go!                          *"
+  echo "*                                                              *"
+  echo "****************************************************************"
+  tput sgr0    # reset to default text
+fi
+