projectlocker_pulse 0.2.1

data/generators/pulse/templates/initializer.rb

@@ -0,0 +1,6 @@
+<% if Rails::VERSION::MAJOR < 3 && Rails::VERSION::MINOR < 2 -%>
+require 'pulse/rails'
+<% end -%>
+Pulse.configure do |config|
+  config.api_key = <%= api_key_expression %>
+end

data/generators/pulse/templates/pulse_tasks.rake

@@ -0,0 +1,25 @@
+# Don't load anything when running the gems:* tasks.
+# Otherwise, projectlocker-pulse will be considered a framework gem.
+# https://thoughtbot.lighthouseapp.com/projects/14221/tickets/629
+unless ARGV.any? {|a| a =~ /^gems/}
+
+  Dir[File.join(Rails.root, 'vendor', 'gems', 'projectlocker-pulse-*')].each do |vendored_notifier|
+    $: << File.join(vendored_notifier, 'lib')
+  end
+
+  begin
+    require 'pulse/tasks'
+  rescue LoadError => exception
+    namespace :pulse do
+      %w(deploy test log_stdout).each do |task_name|
+        desc "Missing dependency for pulse:#{task_name}"
+        task task_name do
+          $stderr.puts "Failed to run pulse:#{task_name} because of missing dependency."
+          $stderr.puts "You probably need to run `rake gems:install` to install the projectlocker-pulse gem"
+          abort exception.inspect
+        end
+      end
+    end
+  end
+
+end

data/install.rb

@@ -0,0 +1 @@
+puts IO.read(File.join(File.dirname(__FILE__), 'INSTALL'))

data/lib/projectlocker_pulse.rb

@@ -0,0 +1,159 @@
+require "girl_friday"
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+require 'pulse/utils/blank'
+require 'pulse/version'
+require 'pulse/configuration'
+require 'pulse/notice'
+require 'pulse/sender'
+require 'pulse/backtrace'
+require 'pulse/rack'
+require 'pulse/user_informer'
+
+require 'pulse/railtie' if defined?(Rails::Railtie)
+
+module Pulse
+  API_VERSION = "2.3"
+  LOG_PREFIX = "** [Pulse] "
+
+  HEADERS = {
+    'Content-type'             => 'text/xml',
+    'Accept'                   => 'text/xml, application/xml'
+  }
+
+  class << self
+    # The sender object is responsible for delivering formatted data to the Pulse server.
+    # Must respond to #send_to_pulse. See Pulse::Sender.
+    attr_accessor :sender
+
+    # A Pulse configuration object. Must act like a hash and return sensible
+    # values for all Pulse configuration options. See Pulse::Configuration.
+    attr_writer :configuration
+
+    # Tell the log that the Notifier is good to go
+    def report_ready
+      write_verbose_log("Notifier #{VERSION} ready to catch errors")
+    end
+
+    # Prints out the environment info to the log for debugging help
+    def report_environment_info
+      write_verbose_log("Environment Info: #{environment_info}")
+    end
+
+    # Prints out the response body from Pulse for debugging help
+    def report_response_body(response)
+      write_verbose_log("Response from Pulse: \n#{response}")
+    end
+
+    # Prints out the details about the notice that wasn't sent to server
+    def report_notice(notice)
+      write_verbose_log("Notice details: \n#{notice}")
+    end
+
+    # Returns the Ruby version, Rails version, and current Rails environment
+    def environment_info
+      info = "[Ruby: #{RUBY_VERSION}]"
+      info << " [#{configuration.framework}]" if configuration.framework
+      info << " [Env: #{configuration.environment_name}]" if configuration.environment_name
+    end
+
+    # Writes out the given message to the #logger
+    def write_verbose_log(message)
+      logger.debug LOG_PREFIX + message if logger
+    end
+
+    # Look for the Rails logger currently defined
+    def logger
+      self.configuration.logger
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Pulse.configure do |config|
+    #     config.api_key = '1234567890abcdef'
+    #     config.secure  = false
+    #   end
+    def configure(silent = false)
+      yield(configuration)
+      self.sender = Sender.new(configuration)
+      report_ready unless silent
+      self.sender
+    end
+
+    # The configuration object.
+    # @see Pulse.configure
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Sends an exception manually using this method, even when you are not in a controller.
+    #
+    # @param [Exception] exception The exception you want to notify Pulse about.
+    # @param [Hash] opts Data that will be sent to Pulse.
+    #
+    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Pulse uses for identification.
+    # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
+    # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
+    # @option opts [String] :rack_env The Rack environment.
+    # @option opts [String] :session The contents of the user's session.
+    # @option opts [String] :environment_name The application environment name.
+    def notify(exception, opts = {})
+      send_notice(build_notice_for(exception, opts))
+    end
+
+    # Sends the notice unless it is one of the default ignored exceptions
+    # @see Pulse.notify
+    def notify_or_ignore(exception, opts = {})
+      notice = build_notice_for(exception, opts)
+      send_notice(notice) unless notice.ignore?
+    end
+
+    def build_lookup_hash_for(exception, options = {})
+      notice = build_notice_for(exception, options)
+
+      result = {}
+      result[:action]           = notice.action      rescue nil
+      result[:component]        = notice.component   rescue nil
+      result[:error_class]      = notice.error_class if notice.error_class
+      result[:environment_name] = 'production'
+
+      unless notice.backtrace.lines.empty?
+        result[:file]        = notice.backtrace.lines.first.file
+        result[:line_number] = notice.backtrace.lines.first.number
+      end
+
+      result
+    end
+
+    private
+
+    def send_notice(notice)
+      if configuration.public?
+        if configuration.async?
+          configuration.async.call(notice)
+        else
+          sender.send_to_pulse(notice)
+        end
+      end
+    end
+
+    def build_notice_for(exception, opts = {})
+      exception = unwrap_exception(exception)
+      opts = opts.merge(:exception => exception) if exception.is_a?(Exception)
+      opts = opts.merge(exception.to_hash) if exception.respond_to?(:to_hash)
+      Notice.new(configuration.merge(opts))
+    end
+
+    def unwrap_exception(exception)
+      if exception.respond_to?(:original_exception)
+        exception.original_exception
+      elsif exception.respond_to?(:continued_exception)
+        exception.continued_exception
+      else
+        exception
+      end
+    end
+  end
+end

data/lib/pulse/backtrace.rb

@@ -0,0 +1,108 @@
+module Pulse
+  # Front end to parsing the backtrace for each notice
+  class Backtrace
+
+    # Handles backtrace parsing line by line
+    class Line
+
+      # regexp (optionnally allowing leading X: for windows support)
+      INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line)
+        _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+        new(file, number, method)
+      end
+
+      def initialize(file, number, method)
+        self.file   = file
+        self.number = number
+        self.method = method
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{to_s}>"
+      end
+
+      private
+
+      attr_writer :file, :number, :method
+    end
+
+    # holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+
+    def self.parse(ruby_backtrace, opts = {})
+      ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+      filters = opts[:filters] || []
+      filtered_lines = ruby_lines.to_a.map do |line|
+        filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end.compact
+
+      lines = filtered_lines.collect do |unparsed_line|
+        Line.parse(unparsed_line)
+      end
+
+      instance = new(lines)
+    end
+
+    def initialize(lines)
+      self.lines = lines
+    end
+
+    def inspect
+      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+    end
+
+    def to_s
+      content = []
+      lines.each do |line|
+        content << line
+      end
+      content.join("\n")
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_writer :lines
+
+    def self.split_multiline_backtrace(backtrace)
+      if backtrace.to_a.size == 1
+        backtrace.to_a.first.split(/\n\s*/)
+      else
+        backtrace
+      end
+    end
+  end
+end

data/lib/pulse/capistrano.rb

@@ -0,0 +1,43 @@
+# Defines deploy:notify_pulse which will send information about the deploy to Pulse.
+require 'capistrano'
+
+module Pulse
+  module Capistrano
+    def self.load_into(configuration)
+      configuration.load do
+        after "deploy",            "pulse:deploy"
+        after "deploy:migrations", "pulse:deploy"
+
+        namespace :pulse do
+          desc <<-DESC
+            Notify Pulse of the deployment by running the notification on the REMOTE machine.
+              - Run remotely so we use remote API keys, environment, etc.
+          DESC
+          task :deploy, :except => { :no_release => true } do
+            rails_env = fetch(:rails_env, "production")
+            pulse_env = fetch(:pulse_env, fetch(:rails_env, "production"))
+            local_user = ENV['USER'] || ENV['USERNAME']
+            executable = RUBY_PLATFORM.downcase.include?('mswin') ? fetch(:rake, 'rake.bat') : fetch(:rake, 'rake')
+            directory = configuration.current_release
+            notify_command = "cd #{directory}; #{executable} RAILS_ENV=#{rails_env} pulse:deploy TO=#{pulse_env} REVISION=#{current_revision} REPO=#{repository} USER=#{local_user}"
+            notify_command << " DRY_RUN=true" if dry_run
+            notify_command << " API_KEY=#{ENV['API_KEY']}" if ENV['API_KEY']
+            logger.info "Notifying Pulse of Deploy (#{notify_command})"
+            if configuration.dry_run
+              logger.info "DRY RUN: Notification not actually run."
+            else
+              result = ""
+              run(notify_command, :once => true) { |ch, stream, data| result << data }
+              # TODO: Check if SSL is active on account via result content.
+            end
+            logger.info "Pulse Notification Complete."
+          end
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  Pulse::Capistrano.load_into(Capistrano::Configuration.instance)
+end

data/lib/pulse/configuration.rb

@@ -0,0 +1,305 @@
+module Pulse
+  # Used to set up and modify settings for the notifier.
+  class Configuration
+
+    OPTIONS = [:api_key, :js_api_key, :backtrace_filters, :development_environments,
+        :development_lookup, :environment_name, :host,
+        :http_open_timeout, :http_read_timeout, :ignore, :ignore_by_filters,
+        :ignore_user_agent, :notifier_name, :notifier_url, :notifier_version,
+        :params_filters, :project_root, :port, :protocol, :proxy_host,
+        :proxy_pass, :proxy_port, :proxy_user, :secure, :use_system_ssl_cert_chain, 
+        :framework, :user_information, :rescue_rake_exceptions].freeze
+
+    # The API key for your project, found on the project edit form.
+    attr_accessor :api_key
+
+    # If you're using the Javascript notifier and would want to separate
+    # Javascript notifications into another Pulse project, specify
+    # its APi key here.
+    # Defaults to #api_key (of the base project)
+    attr_writer :js_api_key
+
+    # The host to connect to (defaults to errors.projectlocker.com).
+    attr_accessor :host
+
+    # The port on which your Pulse server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_accessor :port
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # +true+ to use whatever CAs OpenSSL has installed on your system. +false+ to use the ca-bundle.crt file included in Pulse itself (reccomended and default)
+    attr_accessor :use_system_ssl_cert_chain
+
+    # The HTTP open timeout in seconds (defaults to 2).
+    attr_accessor :http_open_timeout
+
+    # The HTTP read timeout in seconds (defaults to 5).
+    attr_accessor :http_read_timeout
+
+    # The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # A list of parameters that should be filtered out of what is sent to Pulse.
+    # By default, all "password" attributes will have their contents replaced.
+    attr_reader :params_filters
+
+    # A list of filters for cleaning and pruning the backtrace. See #filter_backtrace.
+    attr_reader :backtrace_filters
+
+    # A list of filters for ignoring exceptions. See #ignore_by_filter.
+    attr_reader :ignore_by_filters
+
+    # A list of exception classes to ignore. The array can be appended to.
+    attr_reader :ignore
+
+    # A list of user agents that are being ignored. The array can be appended to.
+    attr_reader :ignore_user_agent
+
+    # A list of environments in which notifications should not be sent.
+    attr_accessor :development_environments
+
+    # +true+ if you want to check for production errors matching development errors, +false+ otherwise.
+    attr_accessor :development_lookup
+
+    # The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # The path to the project in which the error occurred, such as the Rails.root
+    attr_accessor :project_root
+
+    # The name of the notifier library being used to send notifications (such as "Pulse Notifier")
+    attr_accessor :notifier_name
+
+    # The version of the notifier library being used to send notifications (such as "1.0.2")
+    attr_accessor :notifier_version
+
+    # The url of the notifier library being used to send notifications
+    attr_accessor :notifier_url
+
+    # The logger used by Pulse
+    attr_accessor :logger
+
+    # The text that the placeholder is replaced with. {{error_id}} is the actual error number.
+    attr_accessor :user_information
+
+    # The framework Pulse is configured to use
+    attr_accessor :framework
+
+    # Should Pulse catch exceptions from Rake tasks?
+    # (boolean or nil; set to nil to catch exceptions when rake isn't running from a terminal; default is nil)
+    attr_accessor :rescue_rake_exceptions
+
+
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(Pulse.configuration.project_root) && Pulse.configuration.project_root.to_s != ''
+          line.sub(/#{Pulse.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/pulse} }
+    ].freeze
+
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound']
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+    def initialize
+      @secure                   = false
+      @use_system_ssl_cert_chain= false
+      @host                     = 'errors.projectlocker.com'
+      @http_open_timeout        = 2
+      @http_read_timeout        = 5
+      @params_filters           = DEFAULT_PARAMS_FILTERS.dup
+      @backtrace_filters        = DEFAULT_BACKTRACE_FILTERS.dup
+      @ignore_by_filters        = []
+      @ignore                   = IGNORE_DEFAULT.dup
+      @ignore_user_agent        = []
+      @development_environments = %w(development test cucumber)
+      @development_lookup       = true
+      @notifier_name            = 'Pulse Notifier'
+      @notifier_version         = VERSION
+      @notifier_url             = 'http://www.projectlocker.com'
+      @framework                = 'Standalone'
+      @user_information         = 'Pulse Error {{error_id}}'
+      @rescue_rake_exceptions   = nil
+    end
+
+    # Takes a block and adds it to the list of backtrace filters. When the filters
+    # run, the block will be handed each line of the backtrace and can modify
+    # it as necessary.
+    #
+    # @example
+    #   config.filter_bracktrace do |line|
+    #     line.gsub(/^#{Rails.root}/, "[Rails.root]")
+    #   end
+    #
+    # @param [Proc] block The new backtrace filter.
+    # @yieldparam [String] line A line in the backtrace.
+    def filter_backtrace(&block)
+      self.backtrace_filters << block
+    end
+
+    # Takes a block and adds it to the list of ignore filters.
+    # When the filters run, the block will be handed the exception.
+    # @example
+    #   config.ignore_by_filter do |exception_data|
+    #     true if exception_data[:error_class] == "RuntimeError"
+    #   end
+    #
+    # @param [Proc] block The new ignore filter
+    # @yieldparam [Hash] data The exception data given to +Pulse.notify+
+    # @yieldreturn [Boolean] If the block returns true the exception will be ignored, otherwise it will be processed by Pulse.
+    def ignore_by_filter(&block)
+      self.ignore_by_filters << block
+    end
+
+    # Overrides the list of default ignored errors.
+    #
+    # @param [Array<Exception>] names A list of exceptions to ignore.
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    # Overrides the list of default ignored user agents
+    #
+    # @param [Array<String>] A list of user agents to ignore
+    def ignore_user_agent_only=(names)
+      @ignore_user_agent = [names].flatten
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    # Determines if the notifier will send notices.
+    # @return [Boolean] Returns +false+ if in a development environment, +true+ otherwise.
+    def public?
+      !development_environments.include?(environment_name)
+    end
+
+    def port
+      @port || default_port
+    end
+
+    # Determines whether protocol should be "http" or "https".
+    # @return [String] Returns +"http"+ if you've set secure to +false+ in
+    # configuration, and +"https"+ otherwise.
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    # Should Pulse send notifications asynchronously
+    # (boolean, nil or callable; default is nil).
+    # Can be used as callable-setter when block provided.
+    def async(&block)
+      if block_given?
+        @async = block
+      end
+      @async
+    end
+    alias_method :async?, :async
+
+    def async=(use_default_or_this)
+      @async = use_default_or_this == true ?
+        default_async_processor :
+        use_default_or_this
+    end
+
+    def js_api_key
+      @js_api_key || self.api_key
+    end
+
+    def js_notifier=(*args)
+      warn '[PULSE] config.js_notifier has been deprecated and has no effect.  You should use <%= pulse_javascript_notifier %> directly at the top of your layouts.  Be sure to place it before all other javascript.'
+    end
+
+    def environment_filters
+      warn 'config.environment_filters has been deprecated and has no effect.'
+      []
+    end
+
+    def ca_bundle_path
+      if use_system_ssl_cert_chain? && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        OpenSSL::X509::DEFAULT_CERT_FILE
+      else
+        local_cert_path # ca-bundle.crt built from source, see resources/README.md
+      end
+    end
+
+    def local_cert_path
+      File.expand_path(File.join("..", "..", "..", "resources", "ca-bundle.crt"), __FILE__)
+    end
+
+  private
+    # Determines what port should we use for sending notices.
+    # @return [Fixnum] Returns 443 if you've set secure to true in your
+    # configuration, and 80 otherwise.
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+
+    # Async notice delivery defaults to girl friday
+    def default_async_processor
+      queue = GirlFriday::WorkQueue.new(nil, :size => 3) do |notice|
+        Pulse.sender.send_to_pulse(notice)
+      end
+      lambda {|notice| queue << notice}
+    end
+  end
+end