metrician 0.0.1

data/script/test

@@ -0,0 +1,36 @@
+#!/bin/bash
+set -e
+cd "$(dirname "$0")/.."
+
+eval "$(rbenv init - --no-rehash)"
+
+rspec_file_line="$1"
+if [[ "$rspec_file_line" != "" ]]; then
+  rspec_file_line="[${rspec_file_line}]"
+fi
+
+success="true"
+
+for ruby_version in `ruby -ryaml -e 'puts YAML.load(File.read(".travis.yml"))["rvm"].join(" ")'`; do
+  {
+    echo "testing rub version $ruby_version" &&
+      rbenv shell $ruby_version &&
+      bundle exec rake matrix:spec${rspec_file_line}
+  } || success="false"
+done
+
+if [ $success == "true" ]; then
+  tput bold    # bold text
+  tput setaf 2 # green text
+  echo "======================================"
+  echo "=              Passed                ="
+  echo "======================================"
+  tput sgr0    # reset to default text
+else
+  tput bold    # bold text
+  tput setaf 1 # red text
+  echo "======================================"
+  echo "=              FAILED                ="
+  echo "======================================"
+  tput sgr0    # reset to default text
+fi

data/spec/metrician_spec.rb

@@ -0,0 +1,372 @@
+require "spec_helper"
+require "instrumental_agent"
+
+module Metrician
+  def self.null_agent(agent_class: Instrumental::Agent)
+    self.agent = agent_class.new(nil, enabled: false)
+  end
+end
+
+RSpec.describe Metrician do
+  before do
+    Metrician.instance_variable_set("@agent", nil)
+  end
+
+  it "has a version number" do
+    Metrician::VERSION.should_not be nil
+  end
+
+  describe "Metrician.activate" do
+    it "takes an agent" do
+      # if this excepts, the world changed
+      Metrician.activate(Metrician.null_agent)
+    end
+
+    it "excepts if the agent is nil" do
+      lambda { Metrician.activate(nil) }.should raise_error(Metrician::MissingAgent)
+    end
+
+    it "excepts if the agent doesn't define one of the required agent methods" do
+      class BadAgent
+        # this list is from Metrician::REQUIRED_AGENT_METHODS
+        def cleanup; end
+        def gauge; end
+        def increment; end
+        def logger; end
+        # def logger=(value); end
+      end
+      agent = BadAgent.new
+      lambda { Metrician.activate(agent) }.should raise_error(Metrician::IncompatibleAgent)
+    end
+  end
+
+  describe "ActiveRecord" do
+    before do
+      @agent = Metrician.null_agent
+      Metrician.activate(@agent)
+    end
+
+    specify "top level queries are instrumented" do
+      @agent.stub(:gauge)
+      @agent.should_receive(:gauge).with("database.query", anything)
+
+      User.where(name: "foobar").to_a
+    end
+
+    specify "per command instrumentation" do
+      Metrician.configuration[:database][:command][:enabled] = true
+      @agent.stub(:gauge)
+      @agent.should_receive(:gauge).with("database.select", anything)
+
+      User.where(name: "foobar").to_a
+    end
+
+    specify "per table instrumentation" do
+      Metrician.configuration[:database][:table] = true
+      @agent.stub(:gauge)
+      @agent.should_receive(:gauge).with("database.users", anything)
+
+      User.where(name: "foobar").to_a
+    end
+
+    specify "per command and table instrumentation" do
+      Metrician.configuration[:database][:command] = true
+      Metrician.configuration[:database][:table] = true
+      @agent.stub(:gauge)
+      @agent.should_receive(:gauge).with("database.select.users", anything)
+
+      User.where(name: "foobar").to_a
+    end
+  end
+
+  describe "job systems" do
+    describe "delayed_job" do
+      before do
+        @agent = Metrician.null_agent
+        Metrician.activate(@agent)
+      end
+
+      specify "DelayedJob is instrumented" do
+        @agent.stub(:gauge)
+
+        @agent.should_receive(:gauge).with("jobs.run", anything)
+        Delayed::Job.enqueue(TestDelayedJob.new(success: true))
+        Delayed::Worker.new(exit_on_complete: true).start
+      end
+
+      specify "job errors are instrumented" do
+        @agent.stub(:increment)
+
+        @agent.should_receive(:increment).with("jobs.error", 1)
+        Delayed::Job.enqueue(TestDelayedJob.new(error: true))
+        Delayed::Worker.new(exit_on_complete: true).start
+      end
+
+      specify "per job instrumentation" do
+        Metrician.configuration[:jobs][:job_specific][:enabled] = true
+        @agent.stub(:gauge)
+
+        @agent.should_receive(:gauge).with("jobs.run.job.TestDelayedJob", anything)
+        Delayed::Job.enqueue(TestDelayedJob.new(success: true))
+        Delayed::Worker.new(exit_on_complete: true).start
+      end
+    end
+
+    describe "resque" do
+      before do
+        Resque.inline = true
+        @agent = Metrician.null_agent
+        Metrician.activate(@agent)
+      end
+
+      after do
+        Resque.inline = false
+      end
+
+      specify "Resque is instrumented" do
+        @agent.stub(:gauge)
+        @agent.should_receive(:gauge).with("jobs.run", anything)
+
+        # typically Metrician would be loaded in an initalizer
+        # and this _extend_ could be done inside the job itself, but here
+        # we are in a weird situation.
+        TestResqueJob.send(:extend, Metrician::Jobs::ResquePlugin)
+        Resque.enqueue(TestResqueJob, { "success" => true })
+      end
+
+      specify "job errors are instrumented" do
+        @agent.stub(:increment)
+        @agent.should_receive(:increment).with("jobs.error", 1)
+
+        # typically Metrician would be loaded in an initalizer
+        # and this _extend_ could be done inside the job itself, but here
+        # we are in a weird situation.
+        TestResqueJob.send(:extend, Metrician::Jobs::ResquePlugin)
+        lambda { Resque.enqueue(TestResqueJob, { "error" => true }) }.should raise_error(StandardError)
+      end
+    end
+
+    describe "sidekiq" do
+      before do
+        Sidekiq::Testing.inline!
+        @agent = Metrician.null_agent
+        Metrician.activate(@agent)
+        # sidekiq doesn't use middleware by design in their testing
+        # harness, so we add it just as metrician does
+        # https://github.com/mperham/sidekiq/wiki/Testing#testing-server-middleware
+        Sidekiq::Testing.server_middleware do |chain|
+          chain.add Metrician::Jobs::SidekiqMiddleware
+        end
+      end
+
+      after do
+        Sidekiq::Testing.disable!
+      end
+
+      specify "Sidekiq is instrumented" do
+        @agent.stub(:gauge)
+        @agent.should_receive(:gauge).with("jobs.run", anything)
+
+        # avoid load order error of sidekiq here by just including the
+        # worker bits at latest possible time
+        TestSidekiqWorker.perform_async({ "success" => true})
+      end
+
+      specify "job errors are instrumented" do
+        @agent.stub(:increment)
+        @agent.should_receive(:increment).with("jobs.error", 1)
+
+        # avoid load order error of sidekiq here by just including the
+        # worker bits at latest possible time
+        lambda { TestSidekiqWorker.perform_async({ "error" => true}) }.should raise_error(StandardError)
+      end
+    end
+  end
+
+  describe "cache systems" do
+    specify "redis is instrumented" do
+      agent = Metrician.null_agent
+      Metrician.activate(agent)
+      client = Redis.new
+      agent.stub(:gauge)
+      agent.should_receive(:gauge).with("cache.command", anything)
+      client.get("foo-#{rand(100_000)}")
+    end
+
+    memcached_clients = [
+      defined?(::Memcached) && ::Memcached.new("localhost:11211"),
+      defined?(::Dalli::Client) && ::Dalli::Client.new("localhost:11211"),
+    ].compact
+    raise "no memcached client" if memcached_clients.empty?
+
+    memcached_clients.each do |client|
+      specify "memcached is instrumented (#{client.class.name})" do
+        agent = Metrician.null_agent
+        Metrician.activate(agent)
+        agent.stub(:gauge)
+
+        agent.should_receive(:gauge).with("cache.command", anything)
+        begin
+          client.get("foo-#{rand(100_000)}")
+        rescue Memcached::NotFound
+          # memcached raises this when there is no value for "foo-N" set
+        end
+      end
+    end
+  end
+
+  describe "external service timing" do
+    specify "Net::HTTP is instrumented" do
+      agent = Metrician.null_agent
+      Metrician.activate(agent)
+      agent.stub(:gauge)
+
+      agent.should_receive(:gauge).with("service.request", anything)
+      Net::HTTP.get(URI.parse("http://example.com/"))
+    end
+  end
+
+  describe "request timing" do
+    include Rack::Test::Methods
+
+    let(:agent) { Metrician.null_agent }
+
+    describe "success case" do
+      def app
+        require "metrician/middleware/request_timing"
+        require "metrician/middleware/application_timing"
+        Rack::Builder.app do
+          use Metrician::Middleware::RequestTiming
+          use Metrician::Middleware::ApplicationTiming
+          run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
+        end
+      end
+
+      specify "Rack timing is instrumented" do
+        agent.stub(:gauge)
+
+        agent.should_receive(:gauge).with("web.request", anything)
+        get "/"
+      end
+    end
+
+    describe "error case" do
+      def app
+        require "metrician/middleware/request_timing"
+        require "metrician/middleware/application_timing"
+        Rack::Builder.app do
+          use Metrician::Middleware::RequestTiming
+          use Metrician::Middleware::ApplicationTiming
+          run lambda { |env| [500, {'Content-Type' => 'text/plain'}, ['BOOM']] }
+        end
+      end
+
+      specify "500s are instrumented for error tracking" do
+        agent.stub(:gauge)
+        agent.stub(:increment)
+
+        agent.should_receive(:gauge).with("web.request", anything)
+        agent.should_receive(:increment).with("web.error", 1)
+        get "/"
+      end
+    end
+
+    describe "queueing timing" do
+      def app
+        require "metrician/middleware/request_timing"
+        require "metrician/middleware/application_timing"
+        Rack::Builder.app do
+          use Metrician::Middleware::RequestTiming
+          use Metrician::Middleware::ApplicationTiming
+          run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
+        end
+      end
+
+      specify "Queue timing is instrumented" do
+        Metrician.configuration[:request_timing][:queue_time][:enabled] = true
+        agent.stub(:gauge)
+
+        agent.should_receive(:gauge).with("web.queue_time", anything)
+        get "/", {}, { Metrician::Middleware::ENV_QUEUE_START_KEYS.first => 1.second.ago.to_f }
+      end
+    end
+
+    describe "apdex" do
+
+      let(:agent) { Metrician.null_agent }
+
+      describe "fast" do
+        def app
+          require "metrician/middleware/request_timing"
+          require "metrician/middleware/application_timing"
+          Rack::Builder.app do
+            use Metrician::Middleware::RequestTiming
+            use Metrician::Middleware::ApplicationTiming
+            # This SHOULD be fast enough to fit under our
+            # default threshold of 2.5s :)
+            run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
+          end
+        end
+
+        specify "satisfied is recorded" do
+          agent.stub(:gauge)
+
+          agent.should_receive(:gauge).with("web.apdex.satisfied", anything)
+          agent.should_not_receive(:gauge).with("web.apdex.tolerated", anything)
+          agent.should_not_receive(:gauge).with("web.apdex.frustrated", anything)
+          get "/"
+        end
+
+      end
+
+      describe "medium" do
+        def app
+          require "metrician/middleware/request_timing"
+          require "metrician/middleware/application_timing"
+          Rack::Builder.app do
+            use Metrician::Middleware::RequestTiming
+            use Metrician::Middleware::ApplicationTiming
+            run ->(env) {
+              env[Metrician::Middleware::ENV_REQUEST_TOTAL_TIME] = 3.0 # LOAD-BEARING
+              [200, {'Content-Type' => 'text/plain'}, ['OK']]
+            }
+          end
+        end
+
+        specify "tolerated is recorded" do
+          agent.stub(:gauge)
+
+          agent.should_not_receive(:gauge).with("web.apdex.satisfied", anything)
+          agent.should_receive(:gauge).with("web.apdex.tolerated", anything)
+          agent.should_not_receive(:gauge).with("web.apdex.frustrated", anything)
+          get "/"
+        end
+      end
+
+      describe "slow" do
+        def app
+          require "metrician/middleware/request_timing"
+          require "metrician/middleware/application_timing"
+          Rack::Builder.app do
+            use Metrician::Middleware::RequestTiming
+            use Metrician::Middleware::ApplicationTiming
+            run ->(env) {
+              env[Metrician::Middleware::ENV_REQUEST_TOTAL_TIME] = 28.0 # LOAD-BEARING
+              [200, {'Content-Type' => 'text/plain'}, ['OK']]
+            }
+          end
+        end
+
+        specify "frustrated is recorded" do
+          agent.stub(:gauge)
+
+          agent.should_not_receive(:gauge).with("web.apdex.satisfied", anything)
+          agent.should_not_receive(:gauge).with("web.apdex.tolerated", anything)
+          agent.should_receive(:gauge).with("web.apdex.frustrated", anything)
+          get "/"
+        end
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+ENV["RAILS_ENV"] = "test"
+
+require "bundler/setup"
+Bundler.require(:default)
+require "metrician"
+require "gemika"
+require "byebug"
+
+
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].sort.each {|f| require f}
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  config.expect_with :rspec do |c|
+    c.syntax = :should
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :should
+  end
+end

data/spec/support/database.rb

@@ -0,0 +1,33 @@
+database = Gemika::Database.new
+database.connect
+
+if Gemika::Env.gem?('activerecord', '< 5')
+  class ActiveRecord::ConnectionAdapters::Mysql2Adapter
+    NATIVE_DATABASE_TYPES[:primary_key] = "int(11) auto_increment PRIMARY KEY"
+  end
+end
+
+database.rewrite_schema! do
+
+  create_table :users do |t|
+    t.string :name
+    t.string :email
+    t.string :city
+  end
+
+  create_table :delayed_jobs, force: true do |table|
+    table.integer :priority, default: 0, null: false # Allows some jobs to jump to the front of the queue
+    table.integer :attempts, default: 0, null: false # Provides for retries, but still fail eventually.
+    table.text :handler,                 null: false # YAML-encoded string of the object that will do work
+    table.text :last_error                           # reason for last failure (See Note below)
+    table.datetime :run_at                           # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+    table.datetime :locked_at                        # Set when a client is working on this object
+    table.datetime :failed_at                        # Set when all retries have failed (actually, by default, the record is deleted instead)
+    table.string :locked_by                          # Who is working on this object (if locked)
+    table.string :queue                              # The name of the queue this job is in
+    table.timestamps null: true
+  end
+
+  add_index :delayed_jobs, [:priority, :run_at], name: "delayed_jobs_priority"
+
+end