influxdb-rails 0.0.1

data/lib/influxdb/rails/exception_presenter.rb

@@ -0,0 +1,90 @@
+require "base64"
+require "socket"
+
+module InfluxDB
+  module Rails
+    class ExceptionPresenter
+      attr_accessor :hash
+
+      attr_reader :exception
+      attr_reader :backtrace
+      attr_reader :params
+      attr_reader :session_data
+      attr_reader :current_user
+      attr_reader :controller
+      attr_reader :action
+      attr_reader :request_url
+      attr_reader :referer
+      attr_reader :remote_ip
+      attr_reader :user_agent
+      attr_reader :custom_data
+
+      def initialize(e, params = {})
+        e = e.continued_exception if e.respond_to?(:continued_exception)
+        e = e.original_exception if e.respond_to?(:original_exception)
+
+        @exception = e.is_a?(String) ? Exception.new(e) : e
+        @backtrace = InfluxDB::Rails::Backtrace.new(@exception.backtrace)
+        @params = params[:params]
+        @session_data = params[:session_data] || {}
+        @current_user = params[:current_user]
+        @controller = params[:controller]
+        @action = params[:action]
+        @request_url = params[:request_url]
+        @user_agent = params[:user_agent]
+        @referer = params[:referer]
+        @remote_ip = params[:remote_ip]
+        @custom_data = params[:custom_data] || {}
+        @environment_variables = ENV.to_hash || {}
+        @dimensions = {}
+      end
+
+      def context
+        c = {
+          :time => Time.now.utc.to_i,
+          :application_name => InfluxDB::Rails.configuration.application_name,
+          :application_root => InfluxDB::Rails.configuration.application_root,
+          :framework => InfluxDB::Rails.configuration.framework,
+          :framework_version => InfluxDB::Rails.configuration.framework_version,
+          :message => @exception.message,
+          :backtrace => @backtrace.to_a,
+          :language => "Ruby",
+          :language_version => "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}",
+          :custom_data => @custom_data
+        }
+
+        c[:environment_variables] = @environment_variables.reject do |k,v|
+          InfluxDB::Rails.configuration.environment_variable_filters.any? { |filter| k =~ filter }
+        end
+
+        InfluxDB::Rails.configuration.add_custom_exception_data(self)
+
+        c[:request_data] = request_data if @controller || @action || !@params.blank?
+        c
+      end
+
+      def dimensions
+        d = {
+          :class => @exception.class.to_s,
+          :method => "#{@controller}##{@action}",
+          :filename => File.basename(@backtrace.lines.first.try(:file)),
+          :server => Socket.gethostname,
+          :status => "open"
+        }.merge(@dimensions)
+      end
+
+      def request_data
+        {
+          :params => @params,
+          :session_data => @session_data,
+          :controller => @controller,
+          :action => @action,
+          :request_url => @request_url,
+          :referer => @referer,
+          :remote_ip => @remote_ip,
+          :user_agent => @user_agent
+        }
+      end
+    end
+  end
+end

data/lib/influxdb/rails/instrumentation.rb

@@ -0,0 +1,27 @@
+module InfluxDB
+  module Rails
+    module Instrumentation
+      def benchmark_for_instrumentation
+        start = Time.now
+        yield
+
+        unless InfluxDB.configuration.ignore_current_environment?
+          elapsed = ((Time.now - start) * 1000).ceil
+          dimensions = { :method => "#{controller_name}##{action_name}", :server => Socket.gethostname }
+          InfluxDB.aggregate "instrumentation", :value => elapsed, :dimensions => dimensions
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def instrument(methods = [])
+          methods = [methods] unless methods.is_a?(Array)
+          around_filter :benchmark_for_instrumentation, :only => methods
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/logger.rb

@@ -0,0 +1,13 @@
+module InfluxDB
+  module Rails
+    module Logger
+      PREFIX = "[InfluxDB::Rails] "
+
+      private
+      def log(level, message)
+        return if level != :error && ! InfluxDB::Rails.configuration.debug?
+        InfluxDB::Rails.configuration.logger.send(level, PREFIX + message) if InfluxDB.configuration.logger
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/hijack_render_exception.rb

@@ -0,0 +1,21 @@
+module InfluxDB
+  module Rails
+    module Middleware
+      module HijackRenderException
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :influxdb)
+        end
+
+        def render_exception_with_influxdb(env, e)
+          controller = env["action_controller.instance"]
+          request_data = controller.try(:influxdb_request_data) || {}
+          unless InfluxDB::Rails.configuration.ignore_user_agent?(request_data[:user_agent])
+            InfluxDB::Rails.report_exception_unless_ignorable(e, request_data)
+          end
+          render_exception_without_influxdb(env, e)
+        end
+      end
+    end
+  end
+end
+

data/lib/influxdb/rails/middleware/hijack_rescue_action_everywhere.rb

@@ -0,0 +1,32 @@
+module InfluxDB
+  module Rails
+    module Middleware
+      module HijackRescueActionEverywhere
+        def self.included(base)
+          base.send(:alias_method_chain, :rescue_action_in_public, :influxdb)
+          base.send(:alias_method_chain, :rescue_action_locally, :influxdb)
+        end
+
+        private
+        def rescue_action_in_public_with_influxdb(e)
+          handle_exception(e)
+          rescue_action_in_public_without_influxdb(e)
+        end
+
+        def rescue_action_locally_with_influxdb(e)
+          handle_exception(e)
+          rescue_action_locally_without_influxdb(e)
+        end
+
+        def handle_exception(e)
+          request_data = influxdb_request_data || {}
+
+          unless InfluxDB.configuration.ignore_user_agent?(request_data[:user_agent])
+            InfluxDB.report_exception_unless_ignorable(e, request_data)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/influxdb/rails/rack.rb

@@ -0,0 +1,28 @@
+module InfluxDB
+  module Rails
+    class Rack
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        dup._call(env)
+      end
+
+      def _call(env)
+        begin
+          status, headers, body = @app.call(env)
+        rescue => e
+          InfluxDB.transmit_unless_ignorable(e, env)
+          raise(e)
+        ensure
+          _body = []
+          body.each { |line| _body << line } unless body.nil?
+          body.close if body.respond_to?(:close)
+        end
+
+        [status, headers, _body]
+      end
+    end
+  end
+end

data/lib/influxdb/rails/rails.rb

@@ -0,0 +1,39 @@
+require 'action_controller'
+require 'influxdb'
+require 'influxdb/rails/middleware/hijack_rescue_action_everywhere'
+require 'influxdb/rails/air_traffic_controller'
+require 'influxdb/rails/benchmarking'
+require 'influxdb/rails/instrumentation'
+
+module InfluxDB
+  module Rails
+    def self.initialize
+      ActionController::Base.send(:include, InfluxDB::Rails::AirTrafficController)
+      ActionController::Base.send(:include, InfluxDB::Rails::Middleware::HijackRescueActionEverywhere)
+      ActionController::Base.send(:include, InfluxDB::Rails::Benchmarking)
+      ActionController::Base.send(:include, InfluxDB::Rails::Instrumentation)
+
+      ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe', InfluxDB::Rack
+
+      InfluxDB.configure(true) do |config|
+        config.logger                ||= ::Rails.logger
+        config.debug                   = true
+        config.environment           ||= ::Rails.env
+        config.application_root      ||= ::Rails.root
+        config.application_name      ||= "Application"
+        config.framework               = "Rails"
+        config.framework_version       = ::Rails.version
+      end
+
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          InfluxDB::Worker.spawn_threads() if forked
+        end
+      else
+        InfluxDB::Worker.spawn_threads()
+      end
+    end
+  end
+end
+
+InfluxDB::Rails.initialize

data/lib/influxdb/rails/railtie.rb

@@ -0,0 +1,67 @@
+require 'influxdb'
+require 'rails'
+
+module InfluxDB
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "influxdb.insert_rack_middleware" do |app|
+        app.config.middleware.insert 0, InfluxDB::Rails::Rack
+      end
+
+      config.after_initialize do
+        InfluxDB::Rails.configure(true) do |config|
+          config.logger                ||= ::Rails.logger
+          config.environment           ||= ::Rails.env
+          config.application_root      ||= ::Rails.root
+          config.application_name      ||= ::Rails.application.class.parent_name
+          config.framework              = "Rails"
+          config.framework_version       = ::Rails.version
+        end
+
+        ActiveSupport.on_load(:action_controller) do
+          require 'influxdb/rails/air_traffic_controller'
+          include InfluxDB::Rails::AirTrafficController
+          require 'influxdb/rails/instrumentation'
+          include InfluxDB::Rails::Instrumentation
+        end
+
+        if defined?(::ActionDispatch::DebugExceptions)
+          require 'influxdb/rails/middleware/hijack_render_exception'
+          ::ActionDispatch::DebugExceptions.send(:include, InfluxDB::Rails::Middleware::HijackRenderException)
+        elsif defined?(::ActionDispatch::ShowExceptions)
+          require 'influxdb/rails/middleware/hijack_render_exception'
+          ::ActionDispatch::ShowExceptions.send(:include, InfluxDB::Rails::Middleware::HijackRenderException)
+        end
+
+        if defined?(ActiveSupport::Notifications)
+          ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, start, finish, id, payload|
+            if InfluxDB::Rails.configuration.instrumentation_enabled  && ! InfluxDB::Rails.configuration.ignore_current_environment?
+              timestamp = finish.utc.to_i
+              controller_runtime = ((finish - start)*1000).ceil
+              view_runtime = (payload[:view_runtime] || 0).ceil
+              db_runtime = (payload[:db_runtime] || 0).ceil
+              controller_name = payload[:controller]
+              action_name = payload[:action]
+              hostname = Socket.gethostname
+
+              InfluxDB::Rails.client.write_point "rails.controllers",
+                :value => controller_runtime,
+                :method => "#{controller_name}##{action_name}",
+                :server => hostname
+
+              InfluxDB::Rails.client.write_point "rails.views",
+                :value => view_runtime,
+                :method => "#{controller_name}##{action_name}",
+                :server => hostname
+
+              InfluxDB::Rails.client.write_point "rails.db",
+                :value => db_runtime,
+                :method => "#{controller_name}##{action_name}",
+                :server => hostname
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/version.rb

@@ -0,0 +1,5 @@
+module InfluxDB
+  module Rails
+    VERSION = "0.0.1"
+  end
+end

data/lib/rails/generators/influxdb/influxdb_generator.rb

@@ -0,0 +1,52 @@
+require 'rails/generators'
+
+class InfluxDBGenerator < Rails::Generators::Base
+  desc "Description:\n  This creates a Rails initializer for InfluxDB."
+
+  begin
+    if ARGV.count == 1
+      puts "No Application ID provided, contacting InfluxDB API."
+      application_name = Rails.application.class.parent_name || "NewApplication"
+      api_key = ARGV.first
+
+      connection = Net::HTTP.new("influxdb.com", 443)
+      connection.use_ssl = true
+      connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      url = "/api/v1/applications?api_key=#{api_key}&name=#{application_name}"
+      response = connection.post(url, nil)
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise "The InfluxDB API returned an error: #{response.inspect}"
+      end
+
+      @application = JSON.parse(response.body)
+      @application_id = @application["key"]
+    else
+      @application_id = ARGV[1]
+    end
+    puts "Received Application ID: #{@application_id}"
+
+  rescue => e
+    puts "We ran into a problem creating your application via the API!"
+    puts "If this issue persists, contact us at support@influxdb.com with the following details:"
+    puts "#{e.class}: #{e.message}"
+  end
+
+  source_root File.expand_path('../templates', __FILE__)
+  argument :api_key,
+    :required => true,
+    :type => :string,
+    :description => "API key for your InfluxDB organization"
+  argument :application_id,
+    :required => false,
+    :default => @application_id,
+    :type => :string,
+    :description => "Identifier for this application (Leave blank and a new one will be generated for you)"
+
+  def copy_initializer_file
+    template "initializer.rb", "config/initializers/influxdb.rb"
+  end
+
+  def install
+  end
+end

data/lib/rails/generators/influxdb/templates/initializer.rb

@@ -0,0 +1,4 @@
+InfluxDB.configure do |config|
+  config.api_key = "<%= api_key %>"
+  config.application_id = "<%= application_id %>"
+end

data/spec/controllers/widgets_controller_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe WidgetsController do
+  describe "#new" do
+    it "should raise an exception" do
+      expect { get :new }.to raise_error(ZeroDivisionError)
+    end
+  end
+
+  describe "#index" do
+    it "should not raise an exception" do
+      expect { get :index }.to_not raise_error
+    end
+  end
+end

data/spec/integration/exceptions_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + "/integration_helper")
+
+describe "exception handling" do
+  before do
+    InfluxDB::Rails.configure do |config|
+      config.ignored_environments = %w{development}
+      config.instrumentation_enabled = false
+    end
+  end
+
+  describe "in an action that raises an exception" do
+    it "should add an exception to the queue" do
+      InfluxDB::Rails.client.should_receive(:write_point)
+      get "/widgets/new"
+    end
+  end
+
+  describe "in an action that does not raise an exception" do
+    it "should not add anything to the queue" do
+      InfluxDB::Rails.client.should_not_receive(:write_point)
+      get "/widgets"
+    end
+  end
+
+  describe "for an ignored user agent" do
+    it "should not make an HTTP call to the API" do
+      InfluxDB::Rails.client.should_not_receive(:write_point)
+
+      InfluxDB::Rails.configure do |config|
+        config.ignored_user_agents = %w{Googlebot}
+      end
+
+      get "/widgets/new", {}, { "HTTP_USER_AGENT" => "Googlebot/2.1" }
+    end
+  end
+end
+