kuende-opbeat 2.0.1

data/lib/opbeat/interfaces.rb

@@ -0,0 +1,35 @@
+require 'opbeat/better_attr_accessor'
+
+module Opbeat
+
+  INTERFACES = {}
+
+  class Interface
+    include BetterAttrAccessor
+    alias_method :to_hash, :attributes
+
+    def initialize(attributes = nil)
+      attributes.each do |attr, value|
+        send "#{attr}=", value
+      end if attributes
+
+      yield self if block_given?
+    end
+
+    def self.name(value = nil)
+      @interface_name ||= value
+    end
+  end
+
+  def self.register_interface(mapping)
+    mapping.each_pair do |key, klass|
+      INTERFACES[key.to_s] = klass
+      INTERFACES[klass.name] = klass
+    end
+  end
+
+  def self.find_interface(name)
+    INTERFACES[name.to_s]
+  end
+
+end

data/lib/opbeat/interfaces/exception.rb

@@ -0,0 +1,16 @@
+require 'opbeat/interfaces'
+
+module Opbeat
+
+  class ExceptionInterface < Interface
+
+    name 'exception'
+    attr_accessor :type
+    attr_accessor :value
+    attr_accessor :module
+
+  end
+
+  register_interface :exception => ExceptionInterface
+
+end

data/lib/opbeat/interfaces/http.rb

@@ -0,0 +1,57 @@
+require 'opbeat/interfaces'
+
+module Opbeat
+
+  class HttpInterface < Interface
+
+    name 'http'
+    attr_accessor :url
+    attr_accessor :method
+    attr_accessor :data
+    attr_accessor :query_string
+    attr_accessor :cookies
+    attr_accessor :headers
+    attr_accessor :remote_host
+    attr_accessor :http_host
+    attr_accessor :env
+
+    def initialize(*arguments)
+      self.headers = {}
+      self.env = {}
+      super(*arguments)
+    end
+
+    def from_rack(env)
+      require 'rack'
+      req = ::Rack::Request.new(env)
+      self.url = req.url.split('?').first
+      self.method = req.request_method
+      self.query_string = req.query_string
+      self.cookies = req.cookies.collect {|k,v| "#{k}=#{v}"}.join(';')
+      self.remote_host = req.ip
+      self.http_host = req.host_with_port
+      env.each_pair do |key, value|
+        next unless key.upcase == key # Non-upper case stuff isn't either
+        if key.start_with?('HTTP_')
+          # Header
+          http_key = key[5..key.length-1].split('_').map{|s| s.capitalize}.join('-')
+          self.headers[http_key] = value.to_s
+        else
+          # Environment
+          self.env[key] = value.to_s
+        end
+      end
+      self.data = if req.form_data?
+        req.POST
+      elsif req.body
+        data = req.body.read
+        req.body.rewind
+        data
+      end
+    end
+
+  end
+
+  register_interface :http => HttpInterface
+
+end

data/lib/opbeat/interfaces/message.rb

@@ -0,0 +1,19 @@
+require 'opbeat/interfaces'
+
+module Opbeat
+
+  class MessageInterface < Interface
+
+    name 'param_message'
+    attr_accessor :message
+    attr_accessor :params
+
+    def initialize(*arguments)
+      self.params = []
+      super(*arguments)
+    end
+  end
+
+  register_interface :message => MessageInterface
+
+end

data/lib/opbeat/interfaces/stack_trace.rb

@@ -0,0 +1,50 @@
+require 'opbeat/interfaces'
+
+module Opbeat
+
+  class StacktraceInterface < Interface
+
+    name 'stacktrace'
+    attr_accessor :frames, :default => []
+
+    def initialize(*arguments)
+      self.frames = []
+      super(*arguments)
+    end
+
+    def to_hash
+      data = super
+      data['frames'] = data['frames'].map{|frame| frame.to_hash}
+      data
+    end
+
+    def frame(attributes=nil, &block)
+      Frame.new(attributes, &block)
+    end
+
+    # Not actually an interface, but I want to use the same style
+    class Frame < Interface
+      attr_accessor :abs_path
+      attr_accessor :filename
+      attr_accessor :function
+      attr_accessor :vars, :default => {}
+      attr_accessor :pre_context, :default => []
+      attr_accessor :post_context, :default => []
+      attr_accessor :context_line
+      attr_accessor :lineno
+
+      def to_hash
+        data = super
+        data.delete('vars') unless self.vars && !self.vars.empty?
+        data.delete('pre_context') unless self.pre_context && !self.pre_context.empty?
+        data.delete('post_context') unless self.post_context && !self.post_context.empty?
+        data.delete('context_line') unless self.context_line && !self.context_line.empty?
+        data
+      end
+    end
+
+  end
+
+  register_interface :stack_trace => StacktraceInterface
+
+end

data/lib/opbeat/linecache.rb

@@ -0,0 +1,25 @@
+# A much simpler source line cacher because linecache sucks at platform compat
+
+module Opbeat
+
+  class LineCache
+    class << self
+      CACHE = {}
+
+      def getlines(path)
+        CACHE[path] ||= begin
+          IO.readlines(path)
+        rescue
+          []
+        end
+      end
+
+      def getline(path, n)
+        return nil if n < 1
+        getlines(path)[n-1]
+      end
+
+    end
+  end
+
+end

data/lib/opbeat/logger.rb

@@ -0,0 +1,21 @@
+module Opbeat
+  class Logger
+    LOG_PREFIX = "** [Opbeat] "
+
+    [
+      :fatal,
+      :error,
+      :warn,
+      :info,
+      :debug,
+    ].each do |level|
+      define_method level do |*args, &block|
+        msg = args[0] # Block-level default args is a 1.9 feature
+        msg ||= block.call if block
+        logger = Opbeat.configuration[:logger]
+        logger.send(level, "#{LOG_PREFIX}#{msg}") if logger
+      end
+    end
+
+  end
+end

data/lib/opbeat/rack.rb

@@ -0,0 +1,44 @@
+module Opbeat
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Opbeat and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'opbeat'
+  #
+  #   Opbeat.configure do |config|
+  #     config.server = 'http://my_dsn'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     use Opbeat::Rack
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  # Use a standard Opbeat.configure call to configure your server credentials.
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Error => e
+        raise # Don't capture Opbeat errors
+      rescue Exception => e
+        Opbeat.capture_rack_exception(e, env)
+        raise
+      end
+
+      error = env['rack.exception'] || env['sinatra.error']
+
+      if error
+        Opbeat.capture_rack_exception(error, env)
+      end
+
+      response
+    end
+  end
+end

data/lib/opbeat/rails/middleware/debug_exceptions_catcher.rb

@@ -0,0 +1,22 @@
+module Opbeat
+  module Rails
+    module Middleware
+      module DebugExceptionsCatcher
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :opbeat)
+        end
+
+        def render_exception_with_opbeat(env, exception)
+          begin
+            evt = Opbeat::Event.from_rack_exception(exception, env)
+            Opbeat.send(evt) if evt
+          rescue
+            ::Rails::logger.debug "Error capturing or sending exception #{$!}"
+          end
+
+          render_exception_without_opbeat(env, exception)
+        end
+      end
+    end
+  end
+end

data/lib/opbeat/railtie.rb

@@ -0,0 +1,26 @@
+require 'opbeat'
+require 'rails'
+
+module Opbeat
+  class Railtie < ::Rails::Railtie
+    initializer "opbeat.use_rack_middleware" do |app|
+      app.config.middleware.insert 0, "Opbeat::Rack"
+    end
+    config.after_initialize do
+      Opbeat.configure(true) do |config|
+        config.logger ||= ::Rails.logger
+      end
+
+      if defined?(::ActionDispatch::DebugExceptions)
+        require 'opbeat/rails/middleware/debug_exceptions_catcher'
+        ::ActionDispatch::DebugExceptions.send(:include, Opbeat::Rails::Middleware::DebugExceptionsCatcher)
+      elsif defined?(::ActionDispatch::ShowExceptions)
+        require 'opbeat/rails/middleware/debug_exceptions_catcher'
+        ::ActionDispatch::ShowExceptions.send(:include, Opbeat::Rails::Middleware::DebugExceptionsCatcher)
+      end
+    end
+    rake_tasks do
+      require 'opbeat/tasks'
+    end
+  end
+end

data/lib/opbeat/tasks.rb

@@ -0,0 +1,24 @@
+# Capistrano tasks for notifying Opbeat of deploys
+namespace :opbeat do
+  desc "Notify Opbeat of a new deploy."
+  task :deployment do
+    if defined?(::Rails.root)
+      initializer_file = ::Rails.root.join('config', 'initializers','opbeat.rb')
+
+      if initializer_file.exist?
+        load initializer_file
+      else
+        Rake::Task[:environment].invoke
+      end
+    end
+    rev = ENV['REV']
+
+    unless rev
+      puts "No revision given. Set environment variable REV."
+    else
+      data = {'rev' => ENV['REV'], 'branch' => ENV['BRANCH'], 'status' => 'completed'}
+      Opbeat::client.send_release(data)
+    end
+  end
+end
+

data/lib/opbeat/version.rb

@@ -0,0 +1,3 @@
+module Opbeat
+  VERSION = "2.0.1"
+end

data/opbeat.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opbeat/version'
+
+Gem::Specification.new do |gem|
+  gem.name             = "kuende-opbeat"
+  gem.version          = Opbeat::VERSION
+  gem.authors          = ["Thomas Watson Steen", "Ron Cohen", "Noah Kantrowitz"]
+  gem.email            = "support@opbeat.com"
+  gem.summary          = "The official Opbeat Ruby client"
+  gem.homepage         = "https://github.com/kuende/opbeat_ruby"
+  gem.license          = "Apache-2.0"
+
+  gem.files            = `git ls-files -z`.split("\x0")
+  gem.require_paths    = ["lib"]
+  gem.extra_rdoc_files = ["README.md", "LICENSE"]
+
+  gem.add_dependency "faraday", [">= 0.7.6", "< 0.10"]
+  gem.add_dependency "multi_json", "~> 1.12.1"
+
+  gem.add_development_dependency "bundler", "~> 1.7"
+  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "rspec", ">= 2.14"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "delayed_job"
+  gem.add_development_dependency "sidekiq", "~> 2.17.0"
+end

data/spec/opbeat/better_attr_accessor_spec.rb

@@ -0,0 +1,99 @@
+require File::expand_path('../../spec_helper', __FILE__)
+require 'opbeat'
+
+describe Opbeat::BetterAttrAccessor do
+
+  let :klass do
+    Class.new do
+      include Opbeat::BetterAttrAccessor
+
+      attr_accessor :a
+      attr_accessor :b, :default => []
+      attr_accessor :c
+    end
+  end
+
+  let :child do
+    Class.new klass do
+      attr_accessor :d
+    end
+  end
+
+  subject{ klass.new }
+
+  describe 'the reader method' do
+    context 'when a value is not set' do
+      it 'should default to nil' do
+        expect(subject.a).to eq nil
+      end
+      it 'should use a default value if provided' do
+        expect(subject.b).to eq []
+        expect(subject.instance_variable_get '@b').to eq []
+      end
+    end
+
+    context 'when a value is set' do
+      before do
+        subject.a = 'foo'
+        subject.b = :bar
+        subject.c = false
+      end
+
+      it 'should save the value' do
+        expect(subject.a).to eq 'foo'
+      end
+      it 'should save a boolean `false` value' do
+        expect(subject.c).to eq false
+      end
+      it 'should no longer return the default' do
+        expect(subject.b).to eq :bar
+      end
+    end
+
+    context 'when a default value is directly modified' do
+      before { subject.b << 9 }
+      it 'should not affect a new instance' do
+        expect(klass.new.b).to eq []
+      end
+    end
+  end
+
+  describe '.attributes' do
+    it 'should be a Set of all attributes set up' do
+      expect(klass.attributes).to be_a Set
+      expect(klass.attributes).to eq %w[a b c].to_set
+    end
+    it 'should work with inheritance' do
+      expect(child.attributes).to eq %w[d a b c].to_set
+    end
+  end
+
+  describe '#attributes' do
+    it 'should return a hash of all attributes' do
+      subject.a = {'foo' => :bar}
+      subject.b << 8
+      expect(subject.attributes).to eq \
+        'a' => {'foo' => :bar},
+        'b' => [8],
+        'c' => nil
+    end
+
+    describe 'inheritance' do
+      subject{ child.new }
+
+      before do
+        subject.a = 21
+        subject.d = true
+      end
+
+      it 'should work' do
+        expect(subject.attributes).to eq \
+          'a' => 21,
+          'b' => [],
+          'c' => nil,
+          'd' => true
+      end
+    end
+  end
+
+end