projectlocker_pulse 0.2.1

data/features/step_definitions/rake_steps.rb

@@ -0,0 +1,17 @@
+When /I run rake with (.+)/ do |command|
+  @rake_command = "rake #{command.gsub(' ','_')}"
+  @rake_result = `cd features/support/rake && GEM_HOME=#{BUILT_GEM_ROOT} #{@rake_command} 2>&1`
+end
+
+Then /Pulse should (|not) ?catch the exception/ do |condition|
+  if condition=='not'
+    @rake_result.should_not =~ /^pulse/
+  else
+    @rake_result.should =~ /^pulse/
+  end
+end
+
+Then /Pulse should send the rake command line as the component name/ do
+  component = @rake_result.match(/^pulse (.*)$/)[1]
+  component.should == @rake_command
+end

data/features/support/env.rb

@@ -0,0 +1,18 @@
+require 'active_support'
+require 'nokogiri'
+require 'rspec'
+
+PROJECT_ROOT     = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
+TEMP_DIR         = File.join(PROJECT_ROOT, 'tmp').freeze
+LOCAL_RAILS_ROOT = File.join(TEMP_DIR, 'rails_root').freeze
+BUILT_GEM_ROOT   = File.join(TEMP_DIR, 'built_gems').freeze
+LOCAL_GEM_ROOT   = File.join(TEMP_DIR, 'local_gems').freeze
+RACK_FILE        = File.join(TEMP_DIR, 'rack_app.rb').freeze
+
+Before do
+  FileUtils.mkdir_p(TEMP_DIR)
+  FileUtils.rm_rf(BUILT_GEM_ROOT)
+  FileUtils.rm_rf(LOCAL_RAILS_ROOT)
+  FileUtils.rm_f(RACK_FILE)
+  FileUtils.mkdir_p(BUILT_GEM_ROOT)
+end

data/features/support/matchers.rb

@@ -0,0 +1,35 @@
+RSpec::Matchers.define :have_content do |xpath, content|
+  match do |document|
+    @elements = document.search(xpath)
+
+    if @elements.empty?
+      false
+    else
+      element_with_content = document.at("#{xpath}[contains(.,'#{content}')]")
+
+      if element_with_content.nil?
+        @found = @elements.collect { |element| element.content }
+
+        false
+      else
+        true
+      end
+    end
+  end
+
+  failure_message_for_should do |document|
+    if @elements.empty?
+      "In XML:\n#{document}\nNo element at #{xpath}"
+    else
+      "In XML:\n#{document}\nGot content #{@found.inspect} at #{xpath} instead of #{content.inspect}"
+    end
+  end
+
+  failure_message_for_should_not do |document|
+    unless @elements.empty?
+      "In XML:\n#{document}\nExpcted no content #{content.inspect} at #{xpath}"
+    end
+  end
+end
+
+World(RSpec::Matchers)

data/features/support/projectlocker_pulse_shim.rb.template

@@ -0,0 +1,16 @@
+require 'sham_rack'
+
+Pulse.configuration.logger = Logger.new STDOUT if defined?(Pulse)
+
+ShamRack.at("errors.projectlocker.com") do |env|
+  response = <<-end_xml
+<notice>
+<id>b6817316-9c45-ed26-45eb-780dbb86aadb</id>
+<url>http://errors.projectlocker.com/locate/b6817316-9c45-ed26-45eb-780dbb86aadb</url>
+</notice>
+
+Request:
+#{env["rack.input"].read}
+  end_xml
+  ["200 OK", { "Content-type" => "text/xml" }, [response]]
+end

data/features/support/rails.rb

@@ -0,0 +1,201 @@
+module RailsHelpers
+  def rails_root_exists?
+    File.exists?(environment_path)
+  end
+
+  def application_controller_filename
+    controller_filename = File.join(rails_root, 'app', 'controllers', "application_controller.rb")
+  end
+
+  def rails3?
+    rails_version =~ /^3/
+  end
+
+  def rails_root
+    LOCAL_RAILS_ROOT
+  end
+
+  def rails_uses_rack?
+    rails3? || rails_version =~ /^2\.3/
+  end
+
+  def rails_version
+    @rails_version ||= begin
+      if ENV["RAILS_VERSION"]
+        ENV["RAILS_VERSION"]
+      elsif bundler_manages_gems?
+        rails_version = open(gemfile_path).read.match(/gem.*rails["'].*["'](.+)["']/)[1]
+      else
+        environment_file = File.join(rails_root, 'config', 'environment.rb')
+        rails_version = `grep RAILS_GEM_VERSION #{environment_file}`.match(/[\d.]+/)[0]
+      end
+    end
+  end
+
+  def bundler_manages_gems?
+    File.exists?(gemfile_path)
+  end
+
+  def gemfile_path
+    gemfile = File.join(rails_root, 'Gemfile')
+  end
+
+  def rails_manages_gems?
+    rails_version =~ /^2\.[123]/
+  end
+
+  def rails_supports_initializers?
+    rails3? || rails_version =~ /^2\./
+  end
+
+  def rails_finds_generators_in_gems?
+    rails3? || rails_version =~ /^2\./
+  end
+
+  def version_string
+    ENV['RAILS_VERSION'] || `tail -n 1 SUPPORTED_RAILS_VERSIONS` # use latest version if ENV["RAILS_VERSION"] is undefined
+  end
+
+  def environment_path
+    File.join(rails_root, 'config', 'environment.rb')
+  end
+
+  def rakefile_path
+    File.join(rails_root, 'Rakefile')
+  end
+
+  def bundle_gem(gem_name, version = nil)
+    File.open(gemfile_path, 'a') do |file|
+      gem = "gem '#{gem_name}'"
+      gem += ", '#{version}'" if version
+      file.puts(gem)
+    end
+  end
+
+  def config_gem(gem_name, version = nil)
+    run     = "Rails::Initializer.run do |config|"
+    insert  = "  config.gem '#{gem_name}'"
+    insert += ", :version => '#{version}'" if version
+    content = File.read(environment_path)
+    content = "require 'thread'\n#{content}"
+    if content.sub!(run, "#{run}\n#{insert}")
+      File.open(environment_path, 'wb') { |file| file.write(content) }
+    else
+      raise "Couldn't find #{run.inspect} in #{environment_path}"
+    end
+  end
+
+  def config_gem_dependencies
+    insert = <<-END
+    if Gem::VERSION >= "1.3.6"
+      module Rails
+        class GemDependency
+          def requirement
+            r = super
+            (r == Gem::Requirement.default) ? nil : r
+          end
+        end
+      end
+    end
+    END
+    run     = "Rails::Initializer.run do |config|"
+    content = File.read(environment_path)
+    if content.sub!(run, "#{insert}\n#{run}")
+      File.open(environment_path, 'wb') { |file| file.write(content) }
+    else
+      raise "Couldn't find #{run.inspect} in #{environment_path}"
+    end
+  end
+
+  def require_thread
+    content = File.read(rakefile_path)
+    content = "require 'thread'\n#{content}"
+    File.open(rakefile_path, 'wb') { |file| file.write(content) }
+  end
+
+  def perform_request(uri, environment = 'production')
+    if rails3?
+      request_script = <<-SCRIPT
+        require File.expand_path('../config/environment', __FILE__)
+
+
+        env      = Rack::MockRequest.env_for(#{uri.inspect})
+        response = RailsRoot::Application.call(env)
+
+
+        response = response.last if response.last.is_a?(ActionDispatch::Response)
+
+        if response.is_a?(Array)
+          puts response.join
+        else
+          puts response.body
+        end
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/rails runner -e #{environment} request.rb")
+    elsif rails_uses_rack?
+      request_script = <<-SCRIPT
+        require File.expand_path('../config/environment', __FILE__)
+
+        env = Rack::MockRequest.env_for(#{uri.inspect})
+        app = Rack::Lint.new(ActionController::Dispatcher.new)
+
+        status, headers, body = app.call(env)
+
+        response = ""
+        if body.respond_to?(:to_str)
+          response << body
+        else
+          body.each { |part| response << part }
+        end
+
+        puts response
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/runner -e #{environment} request.rb")
+    else
+      uri = URI.parse(uri)
+      request_script = <<-SCRIPT
+        require 'cgi'
+        class CGIWrapper < CGI
+          def initialize(*args)
+            @env_table = {}
+            @stdinput = $stdin
+            super(*args)
+          end
+          attr_reader :env_table
+        end
+        $stdin = StringIO.new("")
+        cgi = CGIWrapper.new
+        cgi.env_table.update({
+          'HTTPS'          => 'off',
+          'REQUEST_METHOD' => "GET",
+          'HTTP_HOST'      => #{[uri.host, uri.port].join(':').inspect},
+          'SERVER_PORT'    => #{uri.port.inspect},
+          'REQUEST_URI'    => #{uri.request_uri.inspect},
+          'PATH_INFO'      => #{uri.path.inspect},
+          'QUERY_STRING'   => #{uri.query.inspect}
+        })
+        require 'dispatcher' unless defined?(ActionController::Dispatcher)
+        Dispatcher.dispatch(cgi)
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/runner -e #{environment} request.rb")
+    end
+  end
+
+  def monkeypatch_old_version
+    monkeypatchin= <<-MONKEYPATCHIN
+
+    MissingSourceFile::REGEXPS << [/^cannot load such file -- (.+)$/i, 1]
+
+    MONKEYPATCHIN
+
+    File.open(File.join(rails_root,"config","initializers", 'monkeypatchin.rb'), 'w') { |file| file.write(monkeypatchin) }
+  end
+end
+
+World(RailsHelpers)

data/features/support/rake/Rakefile

@@ -0,0 +1,68 @@
+# A test harness for RakeHandler
+#
+require 'rake'
+require 'rubygems'
+require 'projectlocker_pulse'
+require 'pulse/rake_handler'
+
+Pulse.configure do |c|
+end
+
+# Should catch exception
+task :pulse do
+  Pulse.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  raise_exception 
+end
+
+# Should not catch exception
+task :pulse_disabled do
+  Pulse.configuration.rescue_rake_exceptions = false
+  stub_tty_output(true)
+  raise_exception 
+end
+
+# Should not catch exception as tty_output is true
+task :pulse_autodetect_from_terminal do
+  Pulse.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(true) 
+  raise_exception 
+end
+
+# Should catch exception as tty_output is false
+task :pulse_autodetect_not_from_terminal do
+  Pulse.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(false) 
+  raise_exception 
+end
+
+task :pulse_not_yet_configured do
+  Pulse.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  stub_empty_sender
+  raise_exception
+end
+
+module Pulse
+  def self.notify_or_ignore(*args)
+    # TODO if you need to check more params, you'll have to use json.dump or something
+    $stderr.puts "pulse #{args[1][:component]}"
+  end
+end
+
+def stub_empty_sender
+  Pulse.sender = nil
+end
+
+def stub_tty_output(value)
+  Rake.application.instance_eval do
+    @tty_output_stub = value
+    def tty_output?
+      @tty_output_stub
+    end
+  end
+end
+
+def raise_exception
+  raise 'TEST'
+end

data/features/support/terminal.rb

@@ -0,0 +1,107 @@
+require 'fileutils'
+
+Before do
+  @terminal = Terminal.new
+end
+
+After do |story|
+  if story.failed?
+    # puts @terminal.output
+  end
+end
+
+class Terminal
+  attr_reader :output, :status
+  attr_accessor :environment_variables, :invoke_heroku_rake_tasks_locally
+
+  def initialize
+    @cwd = FileUtils.pwd
+    @output = ""
+    @status = 0
+    @logger = Logger.new(File.join(TEMP_DIR, 'terminal.log'))
+
+    @invoke_heroku_rake_tasks_locally = false
+
+    @environment_variables = {
+      "GEM_HOME" => LOCAL_GEM_ROOT,
+      "GEM_PATH" => "#{LOCAL_GEM_ROOT}:#{BUILT_GEM_ROOT}",
+      "PATH" => "#{gem_bin_path}:#{ENV['PATH']}"
+    }
+  end
+
+  def cd(directory)
+    @cwd = directory
+  end
+
+  def run(command)
+    command = optionally_invoke_heroku_rake_tasks_locally(command)
+
+    output << "#{command}\n"
+    FileUtils.cd(@cwd) do
+      # The ; forces ruby to shell out so the env settings work right
+      cmdline = "#{environment_settings} #{command} 2>&1 ; "
+      logger.debug(cmdline)
+      result = `#{cmdline}`
+      logger.debug(result)
+      output << result
+    end
+    @status = $?
+  end
+
+  def optionally_invoke_heroku_rake_tasks_locally(command)
+    if invoke_heroku_rake_tasks_locally
+      command.sub(/^heroku /, '')
+    else
+      command
+    end
+  end
+
+  def echo(string)
+    logger.debug(string)
+  end
+
+  def flush!
+    @output = ""
+  end
+
+  def build_and_install_gem(gemspec)
+    pkg_dir = File.join(TEMP_DIR, 'pkg')
+    FileUtils.mkdir_p(pkg_dir)
+    output = `gem build #{gemspec} 2>&1`
+    gem_file = Dir.glob("*.gem").first
+    unless gem_file
+      raise "Gem didn't build:\n#{output}"
+    end
+    target = File.join(pkg_dir, gem_file)
+    FileUtils.mv(gem_file, target)
+    install_gem_to(LOCAL_GEM_ROOT, target)
+  end
+
+  def install_gem(gem)
+    install_gem_to(LOCAL_GEM_ROOT, gem)
+  end
+
+  def uninstall_gem(gem)
+    `gem uninstall -i #{LOCAL_GEM_ROOT} #{gem}`
+  end
+
+  def prepend_path(path)
+    @environment_variables['PATH'] = path + ":" + @environment_variables['PATH']
+  end
+
+  private
+
+  def install_gem_to(root, gem)
+    `gem install -i #{root} --no-ri --no-rdoc #{gem}`
+  end
+
+  def environment_settings
+    @environment_variables.map { |key, value| "#{key}=#{value}" }.join(' ')
+  end
+
+  def gem_bin_path
+    File.join(LOCAL_GEM_ROOT, "bin")
+  end
+
+  attr_reader :logger
+end

data/features/user_informer.feature

@@ -0,0 +1,63 @@
+Feature: Inform the user of the Pulse notice that was just created
+
+  Background:
+    Given I have built and installed the "projectlocker-pulse" gem
+
+  Scenario: Rescue an exception in a controller
+    When I generate a new Rails application
+    And I configure the Pulse shim
+    And I configure my application to require the "projectlocker-pulse" gem
+    And I run the pulse generator with "-k myapikey"
+    And I define a response for "TestController#index":
+      """
+      raise RuntimeError, "some message"
+      """
+    And the response page for a "500" error is
+      """
+      <!-- PROJECTLOCKER_ERRATA ERROR -->
+      """
+    And I route "/test/index" to "test#index"
+    And I perform a request to "http://example.com:123/test/index?param=value"
+    Then I should see "Pulse Error b6817316-9c45-ed26-45eb-780dbb86aadb"
+
+  Scenario: Rescue an exception in a controller with a custom error string
+    When I generate a new Rails application
+    And I configure the Pulse shim
+    And I configure my application to require the "projectlocker-pulse" gem
+    And I configure the notifier to use the following configuration lines:
+    """
+    config.user_information = 'Error #{{ error_id }}'
+    """
+    And I run the pulse generator with "-k myapikey"
+    And I define a response for "TestController#index":
+      """
+      raise RuntimeError, "some message"
+      """
+    And the response page for a "500" error is
+      """
+      <!-- PROJECTLOCKER_ERRATA ERROR -->
+      """
+    And I route "/test/index" to "test#index"
+    And I perform a request to "http://example.com:123/test/index?param=value"
+    Then I should see "Error #b6817316-9c45-ed26-45eb-780dbb86aadb"
+
+  Scenario: Don't inform them user
+    When I generate a new Rails application
+    And I configure the Pulse shim
+    And I configure my application to require the "projectlocker-pulse" gem
+    And I configure the notifier to use the following configuration lines:
+    """
+    config.user_information = false
+    """
+    And I run the pulse generator with "-k myapikey"
+    And I define a response for "TestController#index":
+      """
+      raise RuntimeError, "some message"
+      """
+    And the response page for a "500" error is
+      """
+      <!-- PROJECTLOCKER_ERRATA ERROR -->
+      """
+    And I route "/test/index" to "test#index"
+    And I perform a request to "http://example.com:123/test/index?param=value"
+    Then I should not see "Pulse Error b6817316-9c45-ed26-45eb-780dbb86aadb"

data/generators/pulse/lib/insert_commands.rb

@@ -0,0 +1,34 @@
+# Mostly pinched from http://github.com/ryanb/nifty-generators/tree/master
+
+Rails::Generator::Commands::Base.class_eval do
+  def file_contains?(relative_destination, line)
+    File.read(destination_path(relative_destination)).include?(line)
+  end
+end
+
+Rails::Generator::Commands::Create.class_eval do
+  def append_to(file, line)
+    logger.insert "#{line} appended to #{file}"
+    unless options[:pretend] || file_contains?(file, line)
+      File.open(file, "a") do |file|
+        file.puts
+        file.puts line
+      end
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def append_to(file, line)
+    logger.remove "#{line} removed from #{file}"
+    unless options[:pretend]
+      gsub_file file, "\n#{line}", ''
+    end
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def append_to(file, line)
+    logger.insert "#{line} appended to #{file}"
+  end
+end

data/generators/pulse/lib/rake_commands.rb

@@ -0,0 +1,24 @@
+Rails::Generator::Commands::Create.class_eval do
+  def rake(cmd, opts = {})
+    logger.rake "rake #{cmd}"
+    unless system("rake #{cmd}")
+      logger.rake "#{cmd} failed. Rolling back"
+      command(:destroy).invoke!
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def rake(cmd, opts = {})
+    unless opts[:generate_only]
+      logger.rake "rake #{cmd}"
+      system "rake #{cmd}"
+    end
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def rake(cmd, opts = {})
+    logger.rake "rake #{cmd}"
+  end
+end

data/generators/pulse/pulse_generator.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + "/lib/insert_commands.rb")
+require File.expand_path(File.dirname(__FILE__) + "/lib/rake_commands.rb")
+
+class PulseGenerator < Rails::Generator::Base
+  def add_options!(opt)
+    opt.on('-k', '--api-key=key', String, "Your Pulse API key")                                               { |v| options[:api_key] = v}
+    opt.on('-h', '--heroku',              "Use the Heroku addon to provide your Pulse API key")               { |v| options[:heroku]  = v}
+    opt.on('-a', '--app=myapp', String,   "Your Heroku app name (only required if deploying to >1 Heroku app)") { |v| options[:app]     = v}
+  end
+
+  def manifest
+    if !api_key_configured? && !options[:api_key] && !options[:heroku]
+      puts "Must pass --api-key or --heroku or create config/initializers/pulse.rb"
+      exit
+    end
+    if plugin_is_present?
+      puts "You must first remove the pulse plugin. Please run: script/plugin remove pulse"
+      exit
+    end
+    record do |m|
+      m.directory 'lib/tasks'
+      m.file 'pulse_tasks.rake', 'lib/tasks/pulse_tasks.rake'
+      if ['config/deploy.rb', 'Capfile'].all? { |file| File.exists?(file) }
+        m.append_to 'config/deploy.rb', capistrano_hook
+      end
+      if api_key_expression
+        if use_initializer?
+          m.template 'initializer.rb', 'config/initializers/pulse.rb',
+            :assigns => {:api_key => api_key_expression}
+        else
+          m.template 'initializer.rb', 'config/pulse.rb',
+            :assigns => {:api_key => api_key_expression}
+          m.append_to 'config/environment.rb', "require 'config/pulse'"
+        end
+      end
+      determine_api_key if heroku?
+      m.rake "pulse:test --trace", :generate_only => true
+    end
+  end
+
+  def api_key_expression
+    s = if options[:api_key]
+      "'#{options[:api_key]}'"
+    elsif options[:heroku]
+      "ENV['PULSE_API_KEY']"
+    end
+  end
+
+  def determine_api_key
+    puts "Attempting to determine your API Key from Heroku..."
+    ENV['PULSE_API_KEY'] = heroku_api_key
+    if ENV['PULSE_API_KEY'].blank?
+      puts "... Failed."
+      puts "WARNING: We were unable to detect the Pulse API Key from your Heroku environment."
+      puts "Your Heroku application environment may not be configured correctly."
+      exit 1
+    else
+      puts "... Done."
+      puts "Heroku's Pulse API Key is '#{ENV['PULSE_API_KEY']}'"
+    end
+  end
+
+  def heroku_var(var,app_name = nil)
+    app = app_name ? "--app #{app_name}" : ''
+    `heroku config #{app} | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
+  end
+
+  def heroku_api_key
+    heroku_var("pulse_api_key",options[:app]).split.find {|x| x unless x.blank?}
+  end
+
+  def heroku?
+    options[:heroku] ||
+      system("grep PULSE_API_KEY config/initializers/pulse.rb") ||
+      system("grep PULSE_API_KEY config/environment.rb")
+  end
+
+  def use_initializer?
+    Rails::VERSION::MAJOR > 1
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/pulse.rb') ||
+      system("grep Pulse config/environment.rb")
+  end
+
+  def capistrano_hook
+    IO.read(source_path('capistrano_hook.rb'))
+  end
+
+  def plugin_is_present?
+    File.exists?('vendor/plugins/pulse')
+  end
+end

data/generators/pulse/templates/capistrano_hook.rb

@@ -0,0 +1,6 @@
+
+Dir[File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', 'projectlocker-pulse-*')].each do |vendored_notifier|
+  $: << File.join(vendored_notifier, 'lib')
+end
+
+require 'pulse/capistrano'