bugsnag-maglev- 2.8.12

data/Rakefile

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require 'bundler/gem_tasks'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bugsnag #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# RSpec tasks
+require 'rspec/core'
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default  => :spec

data/VERSION

@@ -0,0 +1 @@
+2.8.12

data/bugsnag.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name = "bugsnag-maglev-"
+  s.version = File.read("VERSION").strip
+
+  s.authors = ["James Smith"]
+  s.email = "james@bugsnag.com"
+
+  s.description = "Ruby notifier for bugsnag.com"
+  s.summary = "Ruby notifier for bugsnag.com"
+  s.homepage = "http://github.com/bugsnag/bugsnag-ruby"
+  s.licenses = ["MIT"]
+
+  s.files = `git ls-files`.split("\n").reject {|file| file.start_with? "example/"}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'json', '~> 1.7', '>= 1.7.5'
+
+  if RUBY_VERSION < "1.9"
+    s.add_development_dependency "rake", "~> 10.1.1"
+  else
+    s.add_development_dependency 'rake'
+  end
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rdoc'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'webmock'
+end

data/lib/bugsnag.rb

@@ -0,0 +1,129 @@
+require "rubygems"
+require "thread"
+
+require "bugsnag/version"
+require "bugsnag/configuration"
+require "bugsnag/meta_data"
+require "bugsnag/notification"
+require "bugsnag/helpers"
+require "bugsnag/deploy"
+
+require "bugsnag/delivery"
+require "bugsnag/delivery/synchronous"
+require "bugsnag/delivery/thread_queue"
+
+require "bugsnag/rack"
+require "bugsnag/railtie" if defined?(Rails::Railtie)
+
+require "bugsnag/middleware/rack_request"
+require "bugsnag/middleware/warden_user"
+require "bugsnag/middleware/callbacks"
+require "bugsnag/middleware/rails3_request"
+require "bugsnag/middleware/sidekiq"
+require "bugsnag/middleware/mailman"
+require "bugsnag/middleware/rake"
+require "bugsnag/middleware/callbacks"
+
+module Bugsnag
+  LOG_PREFIX = "** [Bugsnag] "
+  LOCK = Mutex.new
+
+  class << self
+    # Configure the Bugsnag notifier application-wide settings.
+    def configure(config_hash=nil)
+      if config_hash
+        config_hash.each do |k,v|
+          configuration.send("#{k}=", v) rescue nil if configuration.respond_to?("#{k}=")
+        end
+      end
+
+      yield(configuration) if block_given?
+
+      # Use resque for asynchronous notification if required
+      require "bugsnag/delay/resque" if configuration.delay_with_resque && defined?(Resque)
+
+      # Log that we are ready to rock
+      if configuration.api_key && !@logged_ready
+        log "Bugsnag exception handler #{VERSION} ready, api_key=#{configuration.api_key}"
+        @logged_ready = true
+      end
+    end
+
+    # Explicitly notify of an exception
+    def notify(exception, overrides=nil, request_data=nil)
+      notification = Notification.new(exception, configuration, overrides, request_data)
+      notification.deliver
+      notification
+    end
+
+    # Notify of an exception unless it should be ignored
+    def notify_or_ignore(exception, overrides=nil, request_data=nil)
+      notification = Notification.new(exception, configuration, overrides, request_data)
+
+      unless notification.ignore?
+        notification.deliver
+        notification
+      else
+        false
+      end
+    end
+
+    # Auto notify of an exception, called from rails and rack exception
+    # rescuers, unless auto notification is disabled, or we should ignore this
+    # error class
+    def auto_notify(exception, overrides=nil, request_data=nil)
+      overrides ||= {}
+      overrides.merge!({:severity => "error"})
+      notify_or_ignore(exception, overrides, request_data) if configuration.auto_notify
+    end
+
+    # Log wrapper
+    def log(message)
+      configuration.logger.info("#{LOG_PREFIX}#{message}")
+    end
+
+    # Warning logger
+    def warn(message)
+      configuration.logger.warn("#{LOG_PREFIX}#{message}")
+    end
+
+    # Debug logger
+    def debug(message)
+      configuration.logger.info("#{LOG_PREFIX}#{message}") if configuration.debug
+    end
+
+    # Configuration getters
+    def configuration
+      @configuration || LOCK.synchronize { @configuration ||= Bugsnag::Configuration.new }
+    end
+
+    # Set "per-request" data, temporal data for use in bugsnag middleware
+    def set_request_data(key, value)
+      Bugsnag.configuration.set_request_data(key, value)
+    end
+
+    # Clear all "per-request" data, temporal data for use in bugsnag middleware
+    # This method should be called after each distinct request or session ends
+    # Eg. After completing a page request in a web app
+    def clear_request_data
+      Bugsnag.configuration.clear_request_data
+    end
+
+    # Allow access to "before notify" callbacks
+    def before_notify_callbacks
+      Bugsnag.configuration.request_data[:before_callbacks] ||= []
+    end
+
+    # Allow access to "after notify" callbacks
+    def after_notify_callbacks
+      Bugsnag.configuration.request_data[:after_callbacks] ||= []
+    end
+  end
+end
+
+[:resque, :sidekiq, :mailman, :delayed_job].each do |integration|
+  begin
+    require "bugsnag/#{integration}"
+  rescue LoadError
+  end
+end

data/lib/bugsnag/capistrano.rb

@@ -0,0 +1,7 @@
+require "bugsnag/deploy"
+
+if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  load File.expand_path('../tasks/bugsnag.cap', __FILE__)
+else
+  require_relative 'capistrano2'
+end

data/lib/bugsnag/capistrano2.rb

@@ -0,0 +1,32 @@
+module Bugsnag
+  module Capistrano
+    def self.load_into(configuration)
+      configuration.load do
+        after "deploy",            "bugsnag:deploy"
+        after "deploy:migrations", "bugsnag:deploy"
+
+        namespace :bugsnag do
+          desc "Notify Bugsnag that new production code has been deployed"
+          task :deploy, :except => { :no_release => true }, :on_error => :continue do
+            begin
+              Bugsnag::Deploy.notify({
+                :api_key => fetch(:bugsnag_api_key, ENV["BUGSNAG_API_KEY"]),
+                :release_stage => fetch(:rails_env, ENV["BUGSNAG_RELEASE_STAGE"] || "production"),
+                :revision => fetch(:current_revision, ENV["BUGSNAG_REVISION"]),
+                :repository => fetch(:repository, ENV["BUGSNAG_REPOSITORY"]),
+                :branch => fetch(:branch, ENV["BUGSNAG_BRANCH"],
+                :app_version => fetch(:app_version, ENV["BUGSNAG_APP_VERSION"]))
+              })
+            rescue
+              logger.important("Bugnsag deploy notification failed, #{$!.inspect}")
+            end
+
+            logger.info "Bugsnag deploy notification complete."
+          end
+        end
+      end
+    end
+  end
+end
+
+Bugsnag::Capistrano.load_into(Capistrano::Configuration.instance) if Capistrano::Configuration.instance

data/lib/bugsnag/configuration.rb

@@ -0,0 +1,129 @@
+require "set"
+require "socket"
+require "logger"
+require "bugsnag/middleware_stack"
+
+module Bugsnag
+  class Configuration
+    attr_accessor :api_key
+    attr_accessor :release_stage
+    attr_accessor :notify_release_stages
+    attr_accessor :auto_notify
+    attr_accessor :use_ssl
+    attr_accessor :ca_file
+    attr_accessor :send_environment
+    attr_accessor :send_code
+    attr_accessor :project_root
+    attr_accessor :app_version
+    attr_accessor :app_type
+    attr_accessor :params_filters
+    attr_accessor :ignore_user_agents
+    attr_accessor :endpoint
+    attr_accessor :logger
+    attr_accessor :middleware
+    attr_accessor :internal_middleware
+    attr_accessor :delay_with_resque
+    attr_accessor :debug
+    attr_accessor :proxy_host
+    attr_accessor :proxy_port
+    attr_accessor :proxy_user
+    attr_accessor :proxy_password
+    attr_accessor :timeout
+    attr_accessor :hostname
+    attr_accessor :delivery_method
+    attr_writer :ignore_classes
+
+    THREAD_LOCAL_NAME = "bugsnag_req_data"
+
+    DEFAULT_ENDPOINT = "notify.bugsnag.com"
+
+    DEFAULT_PARAMS_FILTERS = [
+      /authorization/i,
+      /cookie/i,
+      /password/i,
+      /secret/i,
+      "rack.request.form_vars"
+    ].freeze
+
+    DEFAULT_IGNORE_CLASSES = [
+      "AbstractController::ActionNotFound",
+      "ActionController::InvalidAuthenticityToken",
+      "ActionController::ParameterMissing",
+      "ActionController::RoutingError",
+      "ActionController::UnknownAction",
+      "ActionController::UnknownFormat",
+      "ActionController::UnknownHttpMethod",
+      "ActiveRecord::RecordNotFound",
+      "CGI::Session::CookieStore::TamperedWithCookie",
+      "Mongoid::Errors::DocumentNotFound",
+      "SignalException",
+      "SystemExit",
+    ].freeze
+
+    DEFAULT_IGNORE_USER_AGENTS = [].freeze
+
+    DEFAULT_DELIVERY_METHOD = :thread_queue
+
+    def initialize
+      @mutex = Mutex.new
+
+      # Set up the defaults
+      self.auto_notify = true
+      self.use_ssl = true
+      self.send_environment = false
+      self.send_code = true
+      self.params_filters = Set.new(DEFAULT_PARAMS_FILTERS)
+      self.ignore_classes = Set.new(DEFAULT_IGNORE_CLASSES)
+      self.ignore_user_agents = Set.new(DEFAULT_IGNORE_USER_AGENTS)
+      self.endpoint = DEFAULT_ENDPOINT
+      self.hostname = default_hostname
+      self.delivery_method = DEFAULT_DELIVERY_METHOD
+      self.timeout = 15
+
+      # Read the API key from the environment
+      self.api_key = ENV["BUGSNAG_API_KEY"]
+
+      # Set up logging
+      self.logger = Logger.new(STDOUT)
+      self.logger.level = Logger::WARN
+
+      # Configure the bugsnag middleware stack
+      self.internal_middleware = Bugsnag::MiddlewareStack.new
+
+      self.middleware = Bugsnag::MiddlewareStack.new
+      self.middleware.use Bugsnag::Middleware::Callbacks
+    end
+
+    # Accept both String and Class instances as an ignored class
+    def ignore_classes
+      @mutex.synchronize { @ignore_classes.map! { |klass| klass.is_a?(Class) ? klass.name : klass } }
+    end
+
+    def should_notify?
+      @release_stage.nil? || @notify_release_stages.nil? || @notify_release_stages.include?(@release_stage)
+    end
+
+    def request_data
+      Thread.current[THREAD_LOCAL_NAME] ||= {}
+    end
+
+    def set_request_data(key, value)
+      self.request_data[key] = value
+    end
+
+    def unset_request_data(key, value)
+      self.request_data.delete(key)
+    end
+
+    def clear_request_data
+      Thread.current[THREAD_LOCAL_NAME] = nil
+    end
+
+    private
+
+    def default_hostname
+      # Don't send the hostname on Heroku
+      Socket.gethostname unless ENV["DYNO"]
+    end
+  end
+end

data/lib/bugsnag/delay/resque.rb

@@ -0,0 +1,21 @@
+module Bugsnag
+  module Delay
+    class Resque
+      @queue = "bugsnag"
+      def self.perform(*args)
+        Bugsnag::Notification.deliver_exception_payload_without_resque(*args)
+      end
+    end
+  end
+end
+
+Bugsnag::Notification.class_eval do
+  class << self
+    def deliver_exception_payload_with_resque(*args)
+      Resque.enqueue(Bugsnag::Delay::Resque, *args)
+    end
+  
+    alias_method :deliver_exception_payload_without_resque, :deliver_exception_payload
+    alias_method :deliver_exception_payload, :deliver_exception_payload_with_resque
+  end
+end

data/lib/bugsnag/delayed_job.rb

@@ -0,0 +1,57 @@
+require 'delayed_job'
+
+# See Issue #99
+unless defined?(Delayed::Plugin)
+  raise LoadError, "bugsnag requires delayed_job > 3.x"
+end
+
+unless defined? Delayed::Plugins::Bugsnag
+  module Delayed
+    module Plugins
+
+
+      class Bugsnag < Plugin
+        module Notify
+          def error(job, error)
+            overrides = {
+              :job => {
+                :class => job.class.name,
+                :id => job.id,
+              }
+            }
+            if payload = job.payload_object
+              p = {
+                :class => payload.class.name,
+              }
+              p[:id]           = payload.id           if payload.respond_to?(:id)
+              p[:display_name] = payload.display_name if payload.respond_to?(:display_name)
+              p[:method_name]  = payload.method_name  if payload.respond_to?(:method_name)
+              p[:args]         = payload.args         if payload.respond_to?(:args)
+              if payload.is_a?(::Delayed::PerformableMethod) && (object = payload.object)
+                p[:object] = {
+                  :class => object.class.name,
+                }
+                p[:object][:id] = object.id if object.respond_to?(:id)
+              end
+              overrides[:job][:payload] = p
+            end
+
+            ::Bugsnag.auto_notify(error, overrides)
+
+            super if defined?(super)
+          end
+        end
+
+        callbacks do |lifecycle|
+          lifecycle.before(:invoke_job) do |job|
+            payload = job.payload_object
+            payload = payload.object if payload.is_a? Delayed::PerformableMethod
+            payload.extend Notify
+          end
+        end
+      end
+    end
+  end
+
+  Delayed::Worker.plugins << Delayed::Plugins::Bugsnag
+end