kuende-opbeat 2.0.1

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake'
+require 'rubygems/package_task'
+
+gemspec = Gem::Specification.load(Dir['*.gemspec'].first)
+
+Gem::PackageTask.new(gemspec).define
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+  end
+rescue LoadError
+  task :spec do
+    abort "Rspec is not available. bundle install to run unit tests"
+  end
+end
+
+task :default => :spec

data/gemfiles/rails30.gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 3.0.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/rails31.gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 3.1.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/rails32.gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/rails40.gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 4.0.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/rails41.gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 4.1.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/rails42.gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 4.2.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/ruby192_rails31.gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem "i18n", "~> 0.6.11" # pin to <0.7 to support ruby 1.9.2
+gem "rails", "~> 3.1.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/ruby192_rails32.gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem "i18n", "~> 0.6.11" # pin to <0.7 to support ruby 1.9.2
+gem "rails", "~> 3.2.0"
+gem "rake"
+gem "rspec"
+
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/gemfiles/sidekiq31.gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 3.2.6"
+gem "rake"
+gem "rspec"
+gem "simplecov"
+gem "delayed_job"
+gem "sidekiq", "~> 3.1.0"
+gem "opbeat", :path => "../"
+
+gemspec :path => "../"

data/lib/opbeat.rb

@@ -0,0 +1,132 @@
+require 'opbeat/version'
+require 'opbeat/configuration'
+require 'opbeat/logger'
+require 'opbeat/client'
+require 'opbeat/event'
+require 'opbeat/rack'
+require 'opbeat/interfaces/message'
+require 'opbeat/interfaces/exception'
+require 'opbeat/interfaces/stack_trace'
+require 'opbeat/interfaces/http'
+
+require 'opbeat/integrations/delayed_job'
+require 'opbeat/integrations/sidekiq'
+
+require 'opbeat/railtie' if defined?(::Rails::Railtie)
+
+
+module Opbeat
+  class << self
+    # The client object is responsible for delivering formatted data to the Opbeat server.
+    # Must respond to #send_event. See Opbeat::Client.
+    attr_accessor :client
+
+    # A Opbeat configuration object. Must act like a hash and return sensible
+    # values for all Opbeat configuration options. See Opbeat::Configuration.
+    attr_writer :configuration
+
+    def logger
+      @logger ||= Logger.new
+    end
+
+    # Tell the log that the client is good to go
+    def report_ready
+      self.logger.info "Opbeat #{VERSION} ready to catch errors"
+    end
+
+    # The configuration object.
+    # @see Opbeat.configure
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Opbeat.configure do |config|
+    #     config.server = 'http://...'
+    #   end
+    def configure(silent = false)
+      yield(configuration)
+      self.client = Client.new(configuration)
+      report_ready unless silent
+      self.client
+    end
+
+    # Send an event to the configured Opbeat server
+    #
+    # @example
+    #   evt = Opbeat::Event.new(:message => "An error")
+    #   Opbeat.send(evt)
+    def send(evt)
+      @client.send_event(evt) if @client
+    end
+
+    # Capture and process any exceptions from the given block, or globally if
+    # no block is given
+    #
+    # @example
+    #   Opbeat.capture do
+    #     MyApp.run
+    #   end
+    def capture(&block)
+      if block
+        begin
+          block.call
+        rescue Error => e
+          raise # Don't capture Opbeat errors
+        rescue Exception => e
+          self.captureException(e)
+          raise
+        end
+      else
+        # Install at_exit hook
+        at_exit do
+          if $!
+            logger.debug "Caught a post-mortem exception: #{$!.inspect}"
+            self.capture_exception($!)
+          end
+        end
+      end
+    end
+
+    def capture_exception(exception, options={})
+      exception.set_backtrace caller unless exception.backtrace
+      if (evt = Event.from_exception(exception, options))
+        if self.configuration.async?
+          self.configuration.async.call(evt)
+        else
+          send(evt)
+        end
+      end
+    end
+
+    def capture_rack_exception(exception, env, options={})
+      exception.set_backtrace caller unless exception.backtrace
+      if (evt = Event.from_rack_exception(exception, env, options))
+        if self.configuration.async?
+          self.configuration.async.call(evt)
+        else
+          send(evt)
+        end
+      end
+    end
+
+    def capture_message(message, options={})
+      if (evt = Event.from_message(message, caller, options))
+        if self.configuration.async?
+          self.configuration.async.call(evt)
+        else
+          send(evt)
+        end
+      end
+    end
+
+    def set_context(options={})
+      Event.set_context(options)
+    end
+
+    alias :captureException :capture_exception
+    alias :captureMessage :capture_message
+  end
+end

data/lib/opbeat/better_attr_accessor.rb

@@ -0,0 +1,44 @@
+require 'set'
+
+module Opbeat
+  module BetterAttrAccessor
+
+    def attributes
+      Hash[
+        self.class.attributes.map do |attr|
+          [attr, send(attr)]
+        end
+      ]
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def attributes
+        @attributes ||= Set.new
+
+        if superclass.include? BetterAttrAccessor
+          @attributes + superclass.attributes
+        else
+          @attributes
+        end
+      end
+
+      def attr_accessor(attr, options = {})
+        @attributes ||= Set.new
+        @attributes << attr.to_s
+
+        define_method attr do
+          if instance_variable_defined? "@#{attr}"
+            instance_variable_get "@#{attr}"
+          elsif options.key? :default
+            instance_variable_set "@#{attr}", options[:default].dup
+          end
+        end
+        attr_writer attr
+      end
+    end
+  end
+end

data/lib/opbeat/capistrano.rb

@@ -0,0 +1,9 @@
+require 'capistrano'
+require 'capistrano/version'
+
+is_cap3 = Capistrano.constants.include? :VERSION
+if is_cap3
+  load File.expand_path('../capistrano/capistrano3.rb', __FILE__)
+else
+  require_relative 'capistrano/capistrano2'
+end

data/lib/opbeat/capistrano/capistrano2.rb

@@ -0,0 +1,47 @@
+require 'capistrano'
+
+module Opbeat
+  module Capistrano
+    def self.load_into(configuration)
+
+      configuration.load do
+        after "deploy",            "opbeat:notify"
+        after "deploy:migrations", "opbeat:notify"
+        after "deploy:cold",       "opbeat:notify"
+        namespace :opbeat do
+          desc "Notifies Opbeat of new deployments"
+          task :notify, :except => { :no_release => true } do
+
+            scm = fetch(:scm)
+            if scm.to_s != "git"
+              puts "Skipping Opbeat deployment notification because scm is not git."
+              next
+            end
+          
+            branches = capture("cd #{current_release}; /usr/bin/env git branch --contains #{current_revision}").split
+            if branches.length == 1
+              branch = branch[0].sub("* ")
+            else
+              branch = nil
+            end  
+
+            notify_command = "cd #{current_release}; REV=#{current_revision} "
+            notify_command << "BRANCH=#{branch} " if branch
+
+            rails_env = fetch(:rails_env, "production")
+            notify_command << "RAILS_ENV=#{rails_env} "
+
+            executable = fetch(:rake, 'bundle exec rake ')
+            notify_command << "#{executable} opbeat:deployment"
+            capture notify_command, :once => true
+          
+          end
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  Opbeat::Capistrano.load_into(Capistrano::Configuration.instance)
+end

data/lib/opbeat/capistrano/capistrano3.rb

@@ -0,0 +1,26 @@
+namespace :opbeat do
+  desc "Notifies Opbeat of new deployments"
+  task :notify do
+    on roles(:app) do
+
+      scm = fetch(:scm)
+      if scm.to_s != "git"
+        info "Skipping Opbeat deployment because scm is not git."
+        next
+      end
+
+      rev = fetch(:current_revision)
+      branch = fetch(:branch, 'master')
+
+      within release_path do
+        with rails_env: fetch(:rails_env), rev: rev, branch: branch do
+          capture :rake, 'opbeat:deployment'
+        end
+      end
+    end
+  end
+end
+
+namespace :deploy do
+  after :publishing, "opbeat:notify"
+end

data/lib/opbeat/client.rb

@@ -0,0 +1,122 @@
+require 'openssl'
+require 'uri'
+require 'multi_json'
+require 'faraday'
+
+require 'opbeat/version'
+require 'opbeat/error'
+require 'opbeat/filter'
+
+module Opbeat
+
+  class ClientState
+    def initialize(configuration)
+      @configuration = configuration
+      @retry_number = 0
+      @last_check = Time.now
+    end
+
+    def should_try?
+      return true if @status == :online
+
+      interval = ([@retry_number, 6].min() ** 2) * @configuration[:backoff_multiplier]
+      return true if Time.now - @last_check > interval
+
+      false
+    end
+
+    def set_fail
+      @status = :error
+      @retry_number += 1
+      @last_check = Time.now
+    end
+
+    def set_success
+      @status = :online
+      @retry_number = 0
+      @last_check = nil
+    end
+  end
+
+  class Client
+
+    USER_AGENT = "opbeat-ruby/#{Opbeat::VERSION}"
+
+    attr_accessor :configuration
+    attr_accessor :state
+
+    def initialize(conf)
+      raise Error.new('No server specified') unless conf.server
+      raise Error.new('No secret token specified') unless conf.secret_token
+      raise Error.new('No organization ID specified') unless conf.organization_id
+      raise Error.new('No app ID specified') unless conf.app_id
+
+      @configuration = conf
+      @state = ClientState.new conf
+      @filter = Filter.new conf.filter_parameters
+      @base_url = "#{conf.server}/api/v1/organizations/#{conf.organization_id}/apps/#{conf.app_id}"
+      @auth_header = 'Bearer ' + conf.secret_token
+    end
+
+    def conn
+      @conn ||= Faraday.new(@base_url) do |faraday|
+        Opbeat.logger.debug "Initializing connection to #{self.configuration.server}"
+        faraday.adapter Faraday.default_adapter
+        faraday.ssl[:verify] = self.configuration.ssl_verification
+        faraday.options[:timeout] = self.configuration.timeout if self.configuration.timeout
+        faraday.options[:open_timeout] = self.configuration.open_timeout if self.configuration.open_timeout
+      end
+    end
+
+    def encode(event)
+      event_hash = event.to_hash
+      event_hash = @filter.process_event_hash(event_hash)
+      return MultiJson.encode(event_hash)
+    end
+
+    def send(url_postfix, message)
+      begin
+        response = self.conn.post @base_url + url_postfix do |req|
+          req.body = self.encode(message)
+          req.headers['Authorization'] = @auth_header
+          req.headers['Content-Type'] = 'application/json'
+          req.headers['Content-Length'] = req.body.bytesize.to_s
+          req.headers['User-Agent'] = USER_AGENT
+        end
+        unless response.status.between?(200, 299)
+          raise Error.new("Error from Opbeat server (#{response.status}): #{response.body}")
+        end
+      rescue
+        @state.set_fail
+        raise
+      end
+
+      @state.set_success
+      response
+    end
+
+    def send_event(event)
+      return unless configuration.send_in_current_environment?
+      unless state.should_try?
+        Opbeat.logger.info "Temporarily skipping sending to Opbeat due to previous failure."
+        return
+      end
+
+      # Set the organization ID correctly
+      event.organization = self.configuration.organization_id
+      event.app = self.configuration.app_id
+      Opbeat.logger.debug "Sending event to Opbeat"
+      response = send("/errors/", event)
+      if response.status.between?(200, 299)
+        Opbeat.logger.info "Event logged successfully at " + response.headers["location"].to_s
+      end
+      response
+    end
+
+    def send_release(release)
+      Opbeat.logger.debug "Sending release to Opbeat"
+      send("/releases/", release)
+    end
+  end
+
+end