caliper 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in caliper.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,34 @@
+All other components of this product are
+Copyright (c) 2012-2013  Coherence Solutions Inc.  All rights reserved.
+
+Subject to the terms of this notice, Coherence Solutions Inc grants you a
+nonexclusive, nontransferable license, without the right to
+sublicense, to (a) install and execute one copy of these files on any
+number of workstations owned or controlled by you and (b) distribute
+verbatim copies of these files to third parties.  As a condition to the
+foregoing grant, you must provide this notice along with each copy you
+distribute and you must not remove, alter, or obscure this notice. All
+other use, reproduction, modification, distribution, or other
+exploitation of these files is strictly prohibited, except as may be set
+forth in a separate written license agreement between you and Coherence
+Solutions Inc.  The terms of any such license agreement will control over this
+notice.  The license stated above will be automatically terminated and
+revoked if you exceed its scope or violate any of the terms of this
+notice.
+
+This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of Coherence Solutions Inc
+except as required for reasonable and customary use in describing the origin 
+of this file and reproducing the content of this notice.  You may 
+not mark or brand this file with any trade name, trademarks, 
+servicemarks, or product names other than the original brand 
+(if any)provided by Coherence Solutions Inc.
+
+Unless otherwise expressly agreed by Coherence Solutions Inc, in a 
+separate written license agreement, these files are provided AS IS,
+WITHOUT WARRANTY OF ANY KIND, including without any implied warranties
+of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, or NON-INFRINGEMENT. 
+As a condition to your use of these files, you are solely responsible for
+such use. Coherence Solutions Inc will have no liability to you for direct,
+indirect, consequential, incidental, special, or punitive damages or
+for lost profits or data.

data/README.md

@@ -0,0 +1,22 @@
+# Caliper
+
+To use this gem please register for a beta invite at
+[http://caliper.io](http://caliper.io)
+
+## Tests
+
+Caliper gem:
+
+    bundle exec rake
+
+Caliper rails dummy app (could only get rack middleware working with
+IntegrationTest for now):
+
+    cd spec/dummy; bundle exec rake
+
+## Contributing
+
+We welcome pull requests for fixing bugs or new features. We follow the
+[rails coding
+conventions](http://guides.rubyonrails.org/contributing_to_ruby_on_rails.html#follow-the-coding-conventions)
+as best we can.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+# TODO: sort out later
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/caliper.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'caliper/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "caliper"
+  gem.version       = Caliper::VERSION
+  gem.authors       = ["Kalvir Sandhu"]
+  gem.email         = ["kalv@coherence.io"]
+  gem.description   = %q{Caliper your rails applications}
+  gem.summary       = %q{Caliper profiles your rails application giving you insight on customers performance}
+  gem.homepage      = "http://caliper.io"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency(%q<rack>, [">=0"])
+  gem.add_dependency(%q<yajl-ruby>, [">= 0"])
+  gem.add_dependency(%q<uuid>, [">= 0"])
+
+  gem.add_development_dependency(%q<rspec>, [">= 0"])
+  gem.add_development_dependency(%q<activesupport>, [">= 3.2.9"])
+  gem.add_development_dependency(%q<rake>,[">=10.0.2"])
+end

data/lib/caliper/app_error.rb

@@ -0,0 +1,33 @@
+module Caliper
+  module AppError
+    def self.create(exception, request_env)
+      req = ::Rack::Request.new(request_env)
+
+      remote_ip = request_env["action_dispatch.remote_ip"]
+      remote_ip = remote_ip.first if remote_ip.is_a?(Array)
+
+      error_attributes = {
+        "message" => exception.message,
+        "class_name" => exception.class.name,
+        "host" => Socket.gethostname,
+        "request_data" => {
+          "http_method" => request_env["REQUEST_METHOD"],
+          "uri" => request_env["REQUEST_URI"],
+          "path" => request_env["PATH_INFO"],
+          "remote_ip" => "#{remote_ip}",
+          "parameters" => req.params,
+          "session_data" => req.session,
+          "HTTP_USER_AGENT" => request_env["HTTP_USER_AGENT"],
+          "HTTP_HOST" => request_env["HTTP_HOST"],
+          "HTTP_X_REAL_IP" => request_env["HTTP_X_REAL_IP"],
+          "HTTP_X_FORWARDED_FOR" => request_env["HTTP_X_FORWARDED_FOR"]
+        }
+      }
+      error_attributes["backtrace"] = exception.backtrace.join("\n") if exception.backtrace
+
+      CaliperApi.create_error(
+        Yajl::Encoder.encode({"error" => error_attributes})
+      )
+    end
+  end
+end

data/lib/caliper/rack.rb

@@ -0,0 +1,33 @@
+module Caliper
+  class Rack
+    def initialize(app, options = {}, &blk)
+      @app = app
+
+      yield self if block_given?
+    end
+
+    def call(env)
+      if Caliper.config[:enabled] && !env['PATH_INFO'][/^\/assets/]
+        env['caliper.tracer'] = Caliper::Tracer.new(env)
+      end
+
+      @status, @headers, @response = @app.call(env)
+
+      # check for routing error in rails way
+      if @status == 404 && @headers['X-Cascade'] == 'pass'
+        Caliper::AppError.create(
+          ActionController::RoutingError.new("No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"),
+          env
+        )
+      elsif env['caliper.tracer']
+        env['caliper.tracer'].finish
+      end
+
+      [@status, @headers, @response]
+    rescue Exception => exception
+      Caliper::AppError.create(exception, env)
+      raise exception
+    end
+
+  end
+end

data/lib/caliper/rails/append_info.rb

@@ -0,0 +1,25 @@
+# add the resolved controller and action to the trace
+module Caliper
+  module Rails
+    module AppendInfo
+      extend ActiveSupport::Concern
+
+      included do
+        before_filter :add_request_info_to_tracer
+      end
+
+      def add_request_info_to_tracer
+        return true unless env['caliper.tracer'] # elegantly fail if something went wrong with middleware and also when errors are handled
+        request.env["caliper.tracer"].reqs = "#{params[:controller]}##{params[:action]}"
+
+        # check if developer has added customer data
+        if defined? self.add_to_caliper_trace
+          request.env["caliper.tracer"].add_to_trace(self.add_to_caliper_trace)
+        end
+
+        # TODO: add other parameters for the trace?
+      end
+    end
+
+  end
+end

data/lib/caliper/rails/instrumentation.rb

@@ -0,0 +1,27 @@
+# monkey patch the action controller to get reference to middleware caliper tracer
+module ActionController
+  module Instrumentation
+    def process_action(action, *args)
+      raw_payload = {
+        :controller => self.class.name,
+        :action     => self.action_name,
+        :params     => request.filtered_parameters,
+        :formats    => request.formats.map(&:to_sym),
+        :method     => request.method,
+        :path       => (request.fullpath rescue "unknown"),
+
+        # Need payload to reference the request env tracer
+        :caliper_tracer     => request.env['caliper.tracer']
+      }
+
+      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
+
+      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
+        result = super
+        payload[:status] = response.status
+        append_info_to_payload(payload)
+        result
+      end
+    end
+  end
+end

data/lib/caliper/railtie.rb

@@ -0,0 +1,42 @@
+require 'caliper/rails/instrumentation'
+require 'caliper/rails/append_info'
+
+module Caliper
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load "caliper/tasks/caliper.rake"
+    end
+
+    config.caliper = ActiveSupport::OrderedOptions.new
+
+    initializer "caliper.initialize" do |app|
+      app.middleware.use Caliper::Rack
+
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.send(:include, Caliper::Rails::AppendInfo)
+      end
+
+      ActiveSupport::Notifications.subscribe(/(^render|action_controller|active_record)/) do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+
+        # set this so that sql and view notifications has access to caliper tracer
+        if event.name == 'start_processing.action_controller'
+          @caliper_tracer = event.payload[:caliper_tracer]
+        end
+
+        @caliper_tracer.record(event) if @caliper_tracer
+      end
+
+    end
+
+    # update routes to Caliper
+    config.after_initialize do
+      ::Rails.application.reload_routes!
+      inspector = Caliper::RouteInspector.new
+      all_routes = ::Rails.application.routes.routes
+      CaliperApi.update_routes(
+        Yajl::Encoder.encode({"routes" => inspector.routes(all_routes)})
+      )
+    end
+  end
+end

data/lib/caliper/route_inspector.rb

@@ -0,0 +1,108 @@
+# Influenced by ActionDispatch::Routing::RoutesInspector
+require 'delegate'
+
+module Caliper
+
+  class RouteWrapper < SimpleDelegator
+    def endpoint
+      unless rack_app
+        "#{controller}##{action}"
+      end
+      # ignore rack apps for now (don't want to know about redirects)
+      #rack_app ? rack_app.inspect : "#{controller}##{action}"
+    end
+
+    def constraints
+      requirements.except(:controller, :action)
+    end
+
+    def rack_app(app = self.app)
+      @rack_app ||= begin
+        class_name = app.class.name.to_s
+        if class_name == "ActionDispatch::Routing::Mapper::Constraints"
+          rack_app(app.app)
+        elsif ActionDispatch::Routing::Redirect === app || class_name !~ /^ActionDispatch::Routing/
+          app
+        end
+      end
+    end
+
+    def verb
+      super.source.gsub(/[$^]/, '')
+    end
+
+    def path
+      super.spec.to_s
+    end
+
+    def name
+      super.to_s
+    end
+
+    def reqs
+      @reqs ||= begin
+        reqs = endpoint
+        # commenting out for now until tested and really required
+        #reqs += " #{constraints.to_s}" unless constraints.empty?
+        reqs
+      end
+    end
+
+    def controller
+      requirements[:controller] || ':controller'
+    end
+
+    def action
+      requirements[:action] || ':action'
+    end
+
+    def internal?
+      path =~ %r{/rails/info.*|^#{::Rails.application.config.assets.prefix}}
+    end
+
+    def engine?
+      rack_app && rack_app.respond_to?(:routes)
+    end
+  end
+
+  class RouteInspector
+    def initialize
+      @engines = Hash.new
+    end
+
+    def routes(all_routes)
+      routes = collect_routes(all_routes)
+
+      routes + routes_for_engines
+    end
+
+    def collect_routes(routes)
+      routes = routes.collect do |route|
+        RouteWrapper.new(route)
+      end.reject do |route|
+        route.internal?
+      end.collect do |route|
+        collect_engine_routes(route)
+
+        {:name => route.name, :verb => route.verb, :path => route.path, :reqs => route.reqs } unless route.reqs.nil?
+      end.compact
+    end
+
+    def collect_engine_routes(route)
+      name = route.endpoint
+      return unless route.engine?
+      return if @engines[name]
+
+      routes = route.rack_app.routes
+      if routes.is_a?(ActionDispatch::Routing::RouteSet)
+        @engines[name] = collect_routes(routes.routes)
+      end
+    end
+
+    def routes_for_engines
+      @engines.map do |name, routes|
+        formatted_routes(routes)
+      end.flatten
+    end
+  end
+end

data/lib/caliper/tasks/caliper.rake

@@ -0,0 +1,10 @@
+namespace :caliper do
+
+  desc "Send a test call to Caliper to ensure everything is working correctly"
+  task :test => :environment do
+    Rails.logger = Logger.new(STDOUT)
+    puts "Posting a test message to Caliper with API KEY: #{Caliper.config[:api_key]} to #{Caliper.config[:api_host]}"
+    CaliperApi.test_post
+    puts "Test sent. Go ahead and deploy and view data on #{Caliper.config[:api_host]}"
+  end
+end

data/lib/caliper/tracer.rb

@@ -0,0 +1,77 @@
+require 'uuid'
+require 'yajl'
+require 'socket'
+
+module Caliper
+  class Tracer
+    attr_accessor :uuid, :http_method, :uri, :path, :remote_ip, :samples, :host, :reqs, :extra_info
+
+    def initialize(env)
+      @uuid = UUID.generate
+
+      @http_method = env['REQUEST_METHOD']
+      @uri = env['REQUEST_URI'] # full URI
+      @path = env['PATH_INFO'] # user path_info because it's in the rack spec rather than REQUEST_PATH
+
+      @remote_ip = env["action_dispatch.remote_ip"] #requesting ip
+      @remote_ip = @remote_ip.first if @remote_ip.is_a?(Array)
+
+      @host = Socket.gethostname
+
+      @samples = []
+    end
+
+    def record(event)
+      event.payload.delete(:caliper_tracer) if event.payload[:caliper_tracer]
+      return if event.name[/active_record/] && (event.payload[:name] == nil || event.payload[:name][/SCHEMA/])
+
+      # strip un-required payload data for activerecord notifications
+      if event.name[/active_record/]
+        ["binds", "connection_id"].each do |key|
+          event.payload.delete(key)
+        end
+      end
+
+      #Caliper.logger.debug [event.name, event.time, event.end, event.transaction_id, event.payload].join("||")
+      @samples << event
+    end
+
+    def add_to_trace(data = {})
+      @extra_info = data
+    end
+
+    def finish
+      return true if samples.size == 0
+
+      trace_data = {
+        "uuid" => uuid,
+        "http_method" => http_method,
+        "uri" => uri,
+        "path" => path,
+        "remote_ip" => remote_ip.to_s,
+        "host" => host,
+        "reqs" => reqs,
+        "extra_info" => extra_info,
+        "samples" => []
+      }
+
+      samples.each do |sample|
+        trace_data["samples"] << {
+          "name" => sample.name,
+          "duration" => sample.duration,
+          #"start" => sample.time,
+          #"end" => sample.end,
+          "payload" => sample.payload
+        }
+        if sample.name[/process_action.action_controller/]
+          trace_data["view_runtime"] = sample.payload[:view_runtime]
+          trace_data["db_runtime"] = sample.payload[:db_runtime]
+          trace_data["duration"] = sample.duration
+        end
+      end
+      CaliperApi.create_trace(
+        Yajl::Encoder.encode({ "trace" => trace_data })
+      )
+    end
+  end
+end

data/lib/caliper/version.rb

@@ -0,0 +1,3 @@
+module Caliper
+  VERSION = "0.0.1"
+end

data/lib/caliper.rb

@@ -0,0 +1,60 @@
+require 'uuid'
+require 'logger'
+
+require 'caliper/version'
+require 'caliper/tracer'
+require 'caliper/rack'
+require 'caliper/route_inspector'
+require 'caliper/app_error'
+
+require 'caliper_api/http'
+
+
+if defined? ::Rails
+  if ::Rails::VERSION::MAJOR >= 3
+    require 'caliper/railtie'
+  else
+    raise "Your Rails application is currently not supported with Caliper, get in touch we can make it so soon"
+  end
+elsif !ENV["CALIPER_API_HOST"] #(might be in testing mode)
+  raise "Your Ruby application is currently not supported with Caliper, get in touch, we can make it so soon"
+end
+
+module Caliper
+  def self.logger
+    unless @logger
+      # if in Rails use Rails logger
+      if defined? ::Rails
+        @logger = ::Rails.logger
+      else
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::INFO
+      end
+    end
+
+    @logger
+  end
+
+  def self.config
+    if defined? ::Rails
+      config_path = ::Rails.root
+      env = ::Rails.env
+    else
+      config_path = File.new("./")
+      env = "test"
+    end
+    begin
+      @config ||= YAML.load_file("#{config_path.join("config", "caliper.yml")}")[::Rails.env].symbolize_keys
+
+      Caliper.logger.error "No API Key set in caliper.yml" unless @config[:api_key]
+
+      # set host
+      @config[:api_host] = ENV["CALIPER_API_HOST"] || 'http://alpha.caliper.io/'
+
+      @config
+    rescue StandardError => e
+      Caliper.logger.error "No caliper.yml config file could be found!"
+      raise e
+    end
+  end
+end

data/lib/caliper_api/http.rb

@@ -0,0 +1,62 @@
+require 'uri'
+require 'net/http'
+require 'singleton'
+
+module CaliperApi
+
+  class Poster
+    include Singleton
+
+    def initialize
+      @base_uri = Caliper.config[:api_host]
+    end
+
+    def self.send(url, data)
+      instance.post(url, data)
+    end
+
+    def post(url, data = "")
+      begin
+        uri = URI.parse(@base_uri + url)
+        http = Net::HTTP.new(uri.host, uri.port)
+
+        http.open_timeout = 5 # in seconds
+        http.read_timeout = 5 # in seconds
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request["X_API_KEY"] = Caliper.config[:api_key]
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+
+        request.body = data
+
+        response = http.request(request)
+
+        status = response.code.to_i
+        if status == 401
+          Caliper.logger.error "CaliperApi: Error: Not authorized check your API key on #{Caliper.config[:api_host]}"
+        elsif status > 400
+          Caliper.logger.error "CaliperApi: Error: got #{response.code} from server"
+        end
+      rescue Exception => e
+        Caliper.logger.error "CaliperApi: Http error: #{e.message}"
+      end
+    end
+  end
+
+  def self.test_post
+    Poster.send("/api/test", "")
+  end
+
+  def self.create_trace(tracer_json)
+    Poster.send("/api/traces", tracer_json)
+  end
+
+  def self.create_error(error_json)
+    Poster.send("/api/errors", error_json)
+  end
+
+  def self.update_routes(routes_json)
+    Poster.send("/api/routes", routes_json)
+  end
+end

data/spec/caliper/tracer_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Caliper::Tracer do
+
+  it 'should generate a uid on creation' do
+    tracer = Caliper::Tracer.new({"REQEUEST_METHOD" => "POST", "REQUEST_PATH" => "/users"})
+    tracer.uuid.should_not be_nil
+  end
+
+  context "When storing 2 events" do
+    before do
+      @tracer = Caliper::Tracer.new({"REQEUEST_METHOD" => "GET", "REQUEST_PATH" => "/users"})
+      @events = []
+      2.times {
+        event = mock_event
+        @tracer.record(event)
+        @events << event
+      }
+    end
+
+    it 'should store the two events to referencing later' do
+      @tracer.samples.should_not be_nil
+      @tracer.samples.size.should eq 2
+    end
+
+    it 'should post data to CaliperAPI when finished' do
+      CaliperApi.should_receive(:create_trace)
+      @tracer.finish
+    end
+  end
+
+  context "Given a tracer with no samples" do
+    before do
+      @tracer = Caliper::Tracer.new({"REQUEST_METHOD" => "GET", "REQUEST_PATH" => "/users"})
+    end
+
+    it 'should not post data to CaliperAPI when finished' do
+      CaliperApi.should_not_receive(:create_trace)
+      @tracer.finish
+    end
+  end
+
+  context "A typical rails controller request trace" do
+    before do
+      @tracer = Caliper::Tracer.new({"REQEUEST_METHOD" => "GET", "REQUEST_PATH" => "/users"})
+
+      replay_into_tracer(@tracer, "rails_get_request_samples")
+    end
+
+    it 'should have stored correct amount of samples ignoring SCHEMA named events' do
+      @tracer.samples.each do |sample|
+        if sample.name[/active_record/]
+          sample.payload[:name].should_not eq "SCHEMA"
+        end
+      end
+      @tracer.samples.size.should eq 6
+    end
+
+    it 'should dump the correct json data' do
+      pending
+    end
+  end
+
+end

data/spec/data/rails_get_request_samples.txt

@@ -0,0 +1,9 @@
+start_processing.action_controller||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:controller=>"PostsController", :action=>"index", :params=>{"action"=>"index", "controller"=>"posts"}, :formats=>[:html], :method=>"GET", :path=>"/posts"} 
+sql.active_record||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:sql=>"PRAGMA table_info(\"posts\")", :name=>"SCHEMA", :connection_id=>70199742565160, :binds=>[]}
+sql.active_record||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:sql=>"          SELECT name\n          FROM sqlite_master\n          WHERE type = 'table' AND NOT name = 'sqlite_sequence'\n AND name = \"posts\"", :name=>"SCHEMA", :connection_id=>70199742565160, :binds=>[]}
+sql.active_record||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:sql=>"PRAGMA table_info(\"posts\")", :name=>"SCHEMA", :connection_id=>70199742565160, :binds=>[]}
+sql.active_record||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:sql=>"SELECT \"posts\".* FROM \"posts\" ", :name=>"Post Load", :connection_id=>70199742565160, :binds=>[]}
+!render_template.action_view||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:virtual_path=>"posts/index"}
+render_template.action_view||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:identifier=>"/Users/kalv/Development/ruby/test-caliper/app/views/posts/index.html.erb", :layout=>"layouts/application"}
+!render_template.action_view||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:virtual_path=>"layouts/application"}
+process_action.action_controller||2012-11-30 15:07:13 -0800||2012-11-30 15:07:13 -0800||36dc476cf70478c5aecb||{:controller=>"PostsController", :action=>"index", :params=>{"action"=>"index", "controller"=>"posts"}, :formats=>[:html], :method=>"GET", :path=>"/posts", :status=>200, :view_runtime=>22.308999999999997, :db_runtime=>1.735}