projectlocker_pulse 0.2.1

data/lib/pulse/rails.rb

@@ -0,0 +1,40 @@
+require 'projectlocker_pulse'
+require 'pulse/rails/controller_methods'
+require 'pulse/rails/action_controller_catcher'
+require 'pulse/rails/error_lookup'
+require 'pulse/rails/javascript_notifier'
+
+module Pulse
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, Pulse::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, Pulse::Rails::ErrorLookup)
+        ActionController::Base.send(:include, Pulse::Rails::ControllerMethods)
+        ActionController::Base.send(:include, Pulse::Rails::JavascriptNotifier)
+      end
+
+      rails_logger = if defined?(::Rails.logger)
+                       ::Rails.logger
+                     elsif defined?(RAILS_DEFAULT_LOGGER)
+                       RAILS_DEFAULT_LOGGER
+                     end
+
+      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
+        ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
+                                                      Pulse::Rack
+        ::Rails.configuration.middleware.insert_after 'Rack::Lock',
+                                                      Pulse::UserInformer
+      end
+
+      Pulse.configure(true) do |config|
+        config.logger           = rails_logger
+        config.environment_name = defined?(::Rails.env) && ::Rails.env || defined?(RAILS_ENV) && RAILS_ENV
+        config.project_root     = defined?(::Rails.root) && ::Rails.root || defined?(RAILS_ROOT) && RAILS_ROOT
+        config.framework        = defined?(::Rails.version) && "Rails: #{::Rails.version}" || defined?(::Rails::VERSION::STRING) && "Rails: #{::Rails::VERSION::STRING}"
+      end
+    end
+  end
+end
+
+Pulse::Rails.initialize

data/lib/pulse/rails3_tasks.rb

@@ -0,0 +1,99 @@
+require 'projectlocker_pulse'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+puts "\n\nLOADED RAILS3 TASKS\n\n"
+namespace :pulse do
+  desc "Verify your gem installation by sending a test exception to the pulse service"
+  task :test => [:environment] do
+    Rails.logger = defined?(ActiveSupport::TaggedLogging) ?
+      ActiveSupport::TaggedLogging.new(Logger.new(STDOUT)) :
+      Logger.new(STDOUT)
+
+    def wait_for_threads
+      # if using multiple threads, we have to wait for
+      # them to finish
+      if GirlFriday.status.empty?
+        Thread.list.each do |thread|
+          thread.join unless thread == Thread.current
+        end
+      else
+        GirlFriday.shutdown!
+      end
+    end
+
+    Rails.logger.level = Logger::DEBUG
+    Pulse.configure(true) do |config|
+      config.logger = Rails.logger
+    end
+
+    require './app/controllers/application_controller'
+
+    class PulseTestingException < RuntimeError; end
+
+    unless Pulse.configuration.api_key
+      puts "Pulse needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    Pulse.configuration.development_environments = []
+
+    puts "Configuration:"
+    Pulse.configuration.to_hash.each do |key, value|
+      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+    end
+
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found"
+      exit
+    end
+
+    puts 'Setting up the Controller.'
+    class ApplicationController
+      # This is to bypass any filters that may prevent access to the action.
+      prepend_before_filter :test_pulse
+      def test_pulse
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing Pulse via "rake pulse:test". If you can see this, it works.'
+      end
+
+      # def rescue_action(exception)
+      #   rescue_action_in_public exception
+      # end
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      # def consider_all_requests_local
+      #   false
+      # end
+
+      # def local_request?
+      #   false
+      # end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "PulseTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+    class PulseVerificationController < ApplicationController; end
+
+    Rails.application.routes_reloader.execute_if_updated
+    Rails.application.routes.draw do
+      match 'verify' => 'application#verify', :as => 'verify'
+    end
+
+    puts 'Processing request.'
+    env = Rack::MockRequest.env_for("/verify")
+
+    Rails.application.call(env)
+
+    wait_for_threads
+  end
+end

data/lib/pulse/railtie.rb

@@ -0,0 +1,49 @@
+require 'projectlocker_pulse'
+require 'rails'
+
+module Pulse
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      require 'pulse/rake_handler'
+      require 'pulse/rails3_tasks'
+      #load "#{File.dirname(__FILE__)}/rails3_tasks.rb"
+    end
+
+    initializer "pulse.use_rack_middleware" do |app|
+      app.config.middleware.insert 0, "Pulse::UserInformer"
+      app.config.middleware.insert_after "Pulse::UserInformer","Pulse::Rack"
+    end
+
+    config.after_initialize do
+      Pulse.configure(true) do |config|
+        config.logger           ||= config.async? ? ::Logger.new(STDERR) : ::Rails.logger
+        config.environment_name ||= ::Rails.env
+        config.project_root     ||= ::Rails.root
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        # Lazily load action_controller methods
+        #
+        require 'pulse/rails/javascript_notifier'
+        require 'pulse/rails/controller_methods'
+
+        include Pulse::Rails::JavascriptNotifier
+        include Pulse::Rails::ControllerMethods
+      end
+
+      if defined?(::ActionDispatch::DebugExceptions)
+        # We should catch the exceptions in ActionDispatch::DebugExceptions in Rails 3.2.x.
+        #
+        require 'pulse/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::DebugExceptions.send(:include,Pulse::Rails::Middleware::ExceptionsCatcher)
+      elsif defined?(::ActionDispatch::ShowExceptions)
+        # ActionDispatch::DebugExceptions is not defined in Rails 3.0.x and 3.1.x so
+        # catch the exceptions in ShowExceptions.
+        #
+        require 'pulse/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::ShowExceptions.send(:include,Pulse::Rails::Middleware::ExceptionsCatcher)
+      end
+    end
+  end
+end

data/lib/pulse/rake_handler.rb

@@ -0,0 +1,65 @@
+# Patch Rake::Application to handle errors with Pulse
+module Pulse::RakeHandler
+  def self.included(klass)
+    klass.class_eval do
+      include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= '0.9.0'
+      alias_method :display_error_message_without_pulse, :display_error_message
+      alias_method :display_error_message, :display_error_message_with_pulse
+    end
+  end
+
+  def display_error_message_with_pulse(ex)
+    if Pulse.sender && Pulse.configuration &&
+        (Pulse.configuration.rescue_rake_exceptions ||
+          (Pulse.configuration.rescue_rake_exceptions===nil && !self.tty_output?))
+
+      Pulse.notify_or_ignore(ex, :component => reconstruct_command_line, :cgi_data => ENV)
+    end
+
+    display_error_message_without_pulse(ex)
+  end
+
+  def reconstruct_command_line
+    "rake #{ARGV.join( ' ' )}"
+  end
+
+  # This module brings Rake 0.8.7 error handling to 0.9.0 standards
+  module Rake087Methods
+    # Method taken from Rake 0.9.0 source
+    #
+    # Provide standard exception handling for the given block.
+    def standard_exception_handling
+      begin
+        yield
+      rescue SystemExit => ex
+        # Exit silently with current status
+        raise
+      rescue OptionParser::InvalidOption => ex
+        $stderr.puts ex.message
+        exit(false)
+      rescue Exception => ex
+        # Exit with error message
+        display_error_message(ex)
+        exit(false)
+      end
+    end
+
+    # Method extracted from Rake 0.8.7 source
+    def display_error_message(ex)
+      $stderr.puts "#{name} aborted!"
+      $stderr.puts ex.message
+      if options.trace
+        $stderr.puts ex.backtrace.join("\n")
+      else
+        $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+        $stderr.puts "(See full trace by running task with --trace)"
+      end
+    end
+  end
+end
+
+Rake.application.instance_eval do
+  class << self
+    include Pulse::RakeHandler
+  end
+end

data/lib/pulse/sender.rb

@@ -0,0 +1,128 @@
+module Pulse
+  # Sends out the notice to Pulse
+  class Sender
+
+    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
+    HTTP_ERRORS = [Timeout::Error,
+                   Errno::EINVAL,
+                   Errno::ECONNRESET,
+                   EOFError,
+                   Net::HTTPBadResponse,
+                   Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError,
+                   Errno::ECONNREFUSED].freeze
+
+    def initialize(options = {})
+      [ :proxy_host,
+        :proxy_port,
+        :proxy_user,
+        :proxy_pass,
+        :protocol,
+        :host,
+        :port,
+        :secure,
+        :use_system_ssl_cert_chain,
+        :http_open_timeout,
+        :http_read_timeout
+      ].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Sends the notice data off to Pulse for processing.
+    #
+    # @param [Notice or String] notice The notice to be sent off
+    def send_to_pulse(notice)
+      data = notice.respond_to?(:to_xml) ? notice.to_xml : notice
+      http = setup_http_connection
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue *HTTP_ERRORS => e
+                   log :level => :error,
+                       :message => "Unable to contact the Pulse server. HTTP Error=#{e}"
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        log :level => :info,
+            :message => "Success: #{response.class}",
+            :response => response
+      else
+        log :level => :error,
+            :message => "Failure: #{response.class}",
+            :response => response,
+            :notice => notice
+      end
+
+      if response && response.respond_to?(:body)
+        error_id = response.body.match(%r{<id[^>]*>(.*?)</id>})
+        error_id[1] if error_id
+      end
+    rescue => e
+      log :level => :error,
+        :message => "[Pulse::Sender#send_to_pulse] Cannot send notification. Error: #{e.class}" +
+        " - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+
+      nil
+    end
+
+    attr_reader :proxy_host,
+                :proxy_port,
+                :proxy_user,
+                :proxy_pass,
+                :protocol,
+                :host,
+                :port,
+                :secure,
+                :use_system_ssl_cert_chain,
+                :http_open_timeout,
+                :http_read_timeout
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+  private
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    end
+
+    def log(opts = {})
+      opts[:logger].send opts[:level], LOG_PREFIX + opts[:message] if opts[:logger]
+      Pulse.report_environment_info
+      Pulse.report_response_body(opts[:response].body) if opts[:response] && opts[:response].respond_to?(:body)
+      Pulse.report_notice(opts[:notice]) if opts[:notice]
+    end
+
+    def logger
+      Pulse.logger
+    end
+
+    def setup_http_connection
+      http =
+        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
+        new(url.host, url.port)
+
+      http.read_timeout = http_read_timeout
+      http.open_timeout = http_open_timeout
+
+      if secure?
+        http.use_ssl     = true
+
+        http.ca_file      = Pulse.configuration.ca_bundle_path
+        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.use_ssl     = false
+      end
+
+      http
+    rescue => e
+      log :level => :error,
+          :message => "[Pulse::Sender#setup_http_connection] Failure initializing the HTTP connection.\n" +
+                      "Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+      raise e
+    end
+  end
+end

data/lib/pulse/shared_tasks.rb

@@ -0,0 +1,47 @@
+namespace :pulse do
+  desc "Notify Pulse of a new deploy."
+  task :deploy do
+    require 'pulse_tasks'
+
+    if defined?(Rails.root)
+      initializer_file = Rails.root.join('config', 'initializers','pulse.rb')
+
+      if initializer_file.exist?
+        load initializer_file
+      else
+        Rake::Task[:environment].invoke
+      end
+    end
+
+    PulseTasks.deploy(:rails_env      => ENV['TO'],
+                        :scm_revision   => ENV['REVISION'],
+                        :scm_repository => ENV['REPO'],
+                        :local_username => ENV['USER'],
+                        :api_key        => ENV['API_KEY'],
+                        :dry_run        => ENV['DRY_RUN'])
+  end
+
+  task :log_stdout do
+    require 'logger'
+    RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
+  end
+
+  namespace :heroku do
+    desc "Install Heroku deploy notifications addon"
+    task :add_deploy_notification => [:environment] do
+
+      def heroku_var(var)
+        `heroku config | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
+      end
+
+      heroku_rails_env = heroku_var("rails_env")
+      heroku_api_key = heroku_var("pulse_api_key").split.find {|x| x unless x.blank?} ||
+        Pulse.configuration.api_key
+
+      command = %Q(heroku addons:add deployhooks:http --url="http://errors.projectlocker.com/deploys.txt?deploy[rails_env]=#{heroku_rails_env}&api_key=#{heroku_api_key}")
+
+      puts "\nRunning:\n#{command}\n"
+      puts `#{command}`
+    end
+  end
+end

data/lib/pulse/tasks.rb

@@ -0,0 +1,83 @@
+require 'projectlocker_pulse'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :pulse do
+  desc "Verify your gem installation by sending a test exception to the pulse service"
+  task :test => ['pulse:log_stdout', :environment] do
+    RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+
+    require 'action_controller/test_process'
+
+    Dir["app/controllers/application*.rb"].each { |file| require(File.expand_path(file)) } 
+
+    class PulseTestingException < RuntimeError; end
+
+    unless Pulse.configuration.api_key
+      puts "Pulse needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    Pulse.configuration.development_environments = []
+
+    catcher = Pulse::Rails::ActionControllerCatcher
+    in_controller = ApplicationController.included_modules.include?(catcher)
+    in_base = ActionController::Base.included_modules.include?(catcher)
+    if !in_controller || !in_base
+      puts "Rails initialization did not occur"
+      exit
+    end
+
+    puts "Configuration:"
+    Pulse.configuration.to_hash.each do |key, value|
+      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+    end
+
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found"
+      exit
+    end
+
+    puts 'Setting up the Controller.'
+    class ApplicationController
+      # This is to bypass any filters that may prevent access to the action.
+      prepend_before_filter :test_pulse
+      def test_pulse
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing Pulse via "rake pulse:test". If you can see this, it works.'
+      end
+
+      def rescue_action(exception)
+        rescue_action_in_public exception
+      end
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      def consider_all_requests_local
+        false
+      end
+
+      def local_request?
+        false
+      end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "PulseTestingException"
+        exception_name.split("::").inject(Object){|klass, name| klass.const_get(name)}
+      rescue
+        Object.const_set(exception_name.gsub(/:+/, "_"), Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+    class PulseVerificationController < ApplicationController; end
+
+    puts 'Processing request.'
+    request = ActionController::TestRequest.new("REQUEST_URI" => "/pulse_verification_controller")
+    response = ActionController::TestResponse.new
+    PulseVerificationController.new.process(request, response)
+  end
+end
+

data/lib/pulse/user_informer.rb

@@ -0,0 +1,27 @@
+module Pulse
+  class UserInformer
+    def initialize(app)
+      @app = app
+    end
+
+    def replacement(with)
+      Pulse.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      if env['pulse.error_id'] && Pulse.configuration.user_information
+        new_body = []
+        replace  = replacement(env['pulse.error_id'])
+        body.each do |chunk|
+          new_body << chunk.gsub("<!-- PULSE ERROR -->", replace)
+        end
+        body.close if body.respond_to?(:close)
+        headers['Content-Length'] = new_body.sum(&:bytesize).to_s
+        body = new_body
+      end
+      [status, headers, body]
+    end
+  end
+end
+

data/lib/pulse/utils/blank.rb

@@ -0,0 +1,53 @@
+# stolen from ActiveSupport
+
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def present?
+    !blank?
+  end
+
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class Array
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  alias_method :blank?, :empty?
+end
+
+class String
+  def blank?
+    self !~ /[^[:space:]]/
+  end
+end
+
+class Numeric
+  def blank?
+    false
+  end
+end

data/lib/pulse/version.rb

@@ -0,0 +1,3 @@
+module Pulse
+  VERSION = "0.2.1".freeze
+end

data/lib/pulse_tasks.rb

@@ -0,0 +1,64 @@
+require 'net/http'
+require 'uri'
+
+# Capistrano tasks for notifying Pulse of deploys
+module PulseTasks
+
+  # Alerts Pulse of a deploy.
+  #
+  # @param [Hash] opts Data about the deploy that is set to Pulse
+  #
+  # @option opts [String] :api_key Api key of you Pulse application
+  # @option opts [String] :rails_env Environment of the deploy (production, staging)
+  # @option opts [String] :scm_revision The given revision/sha that is being deployed
+  # @option opts [String] :scm_repository Address of your repository to help with code lookups
+  # @option opts [String] :local_username Who is deploying
+  def self.deploy(opts = {})
+    api_key = opts.delete(:api_key) || Pulse.configuration.api_key
+    if api_key.blank?
+      puts "I don't seem to be configured with an API key.  Please check your configuration."
+      return false
+    end
+
+    if opts[:rails_env].blank?
+      puts "I don't know to which Rails environment you are deploying (use the TO=production option)."
+      return false
+    end
+
+    dry_run = opts.delete(:dry_run)
+    params = {'api_key' => api_key}
+    opts.each {|k,v| params["deploy[#{k}]"] = v }
+
+    host = Pulse.configuration.host || 'errors.projectlocker.com'
+    port = Pulse.configuration.port
+
+    proxy = Net::HTTP.Proxy(Pulse.configuration.proxy_host,
+                            Pulse.configuration.proxy_port,
+                            Pulse.configuration.proxy_user,
+                            Pulse.configuration.proxy_pass)
+    http = proxy.new(host, port)
+
+
+
+    # Handle Security
+    if Pulse.configuration.secure?
+      http.use_ssl      = true
+      http.ca_file      = Pulse.configuration.ca_bundle_path
+      http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    post = Net::HTTP::Post.new("/deploys.txt")
+    post.set_form_data(params)
+
+    if dry_run
+      puts http.inspect, params.inspect
+      return true
+    else
+      response = http.request(post)
+
+      puts response.body
+      return Net::HTTPSuccess === response
+    end
+  end
+end
+