opbeat 2.0.0 → 3.0.0

data/lib/opbeat/injections/sequel.rb

@@ -0,0 +1,32 @@
+module Opbeat
+  module Injections
+    module Sequel
+      class Injector
+        KIND = 'db.sequel.sql'.freeze
+
+        def self.sql_parser
+          @sql_parser ||= SqlSummarizer.new(nil)
+        end
+
+        def install
+          require 'sequel/database/logging'
+
+          ::Sequel::Database.class_eval do
+            alias log_yield_without_opb log_yield
+
+            def log_yield sql, args = nil, &block
+              log_yield_without_opb(sql, *args) do
+                sig = Opbeat::Injections::Sequel::Injector.sql_parser.signature_for(sql)
+                Opbeat.trace(sig, KIND, sql: sql) do
+                  block.call
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Sequel', 'sequel', Sequel::Injector.new
+  end
+end

data/lib/opbeat/injections/sinatra.rb

@@ -0,0 +1,56 @@
+module Opbeat
+  module Injections
+    module Sinatra
+      class Injector
+        def install
+          ::Sinatra::Base.class_eval do
+            alias dispatch_without_opb! dispatch!
+            alias compile_template_with_opb compile_template
+
+            def dispatch!(*args, &block)
+              dispatch_without_opb!(*args, &block).tap do
+                if route = env['sinatra.route']
+                  Opbeat.transaction(nil).endpoint = route
+                end
+              end
+            end
+
+            def compile_template engine, data, opts, *args, &block
+              case data
+              when Symbol
+                opts[:__opbeat_template_sig] = data.to_s
+              else
+                opts[:__opbeat_template_sig] = "Inline #{engine}"
+              end
+
+              compile_template_with_opb(engine, data, opts, *args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    module Tilt
+      class Injector
+        KIND = 'template.view'
+
+        def install
+          ::Tilt::Template.class_eval do
+            alias render_without_opb render
+
+            def render(*args, &block)
+              sig = options[:__opbeat_template_sig] || 'Uknown template'.freeze
+
+              Opbeat.trace sig, KIND do
+                render_without_opb(*args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Sinatra::Base', 'sinatra/base', Sinatra::Injector.new
+    register 'Tilt::Template', 'tilt/template', Tilt::Injector.new
+  end
+end

data/lib/opbeat/{capistrano → integration}/capistrano2.rb

@@ -1,6 +1,5 @@
-require 'capistrano'
-
 module Opbeat
+  # @api private
   module Capistrano
     def self.load_into(configuration)
 
@@ -17,13 +16,13 @@ module Opbeat
               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  
+            end
 
             notify_command = "cd #{current_release}; REV=#{current_revision} "
             notify_command << "BRANCH=#{branch} " if branch
@@ -32,9 +31,9 @@ module Opbeat
             notify_command << "RAILS_ENV=#{rails_env} "
 
             executable = fetch(:rake, 'bundle exec rake ')
-            notify_command << "#{executable} opbeat:deployment"
+            notify_command << "#{executable} opbeat:release"
             capture notify_command, :once => true
-          
+
           end
         end
       end
@@ -45,3 +44,4 @@ end
 if Capistrano::Configuration.instance
   Opbeat::Capistrano.load_into(Capistrano::Configuration.instance)
 end
+

data/lib/opbeat/{capistrano → integration}/capistrano3.rb

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

data/lib/opbeat/{integrations → integration}/delayed_job.rb

@@ -3,23 +3,19 @@ begin
 rescue LoadError
 end
 
-# Based on the Sentry equivalent.
 if defined?(Delayed)
-
   module Delayed
     module Plugins
-      class Opbeat < ::Delayed::Plugin
+      class Opbeat < Delayed::Plugin
         callbacks do |lifecycle|
           lifecycle.around(:invoke_job) do |job, *args, &block|
             begin
-              # Forward the call to the next callback in the callback chain
               block.call(job, *args)
-
+            rescue ::Opbeat::Error
+              raise # don't report Opbeat errors
             rescue Exception => exception
-              # Log error to Opbeat
-              ::Opbeat.capture_exception(exception)
-              # Make sure we propagate the failure!
-              raise exception
+              ::Opbeat.report exception
+              raise
             end
           end
         end
@@ -27,6 +23,5 @@ if defined?(Delayed)
     end
   end
 
-  # Register DelayedJob Opbeat plugin
   Delayed::Worker.plugins << Delayed::Plugins::Opbeat
-end
+end

data/lib/opbeat/integration/rails/inject_exceptions_catcher.rb

@@ -0,0 +1,23 @@
+module Opbeat
+  module Integration
+    module Rails
+      module InjectExceptionsCatcher
+        def self.included(cls)
+          cls.send(:alias_method_chain, :render_exception, :opbeat)
+        end
+
+        def render_exception_with_opbeat(env, exception)
+          begin
+            Opbeat.report(exception, rack_env: env) if Opbeat.started?
+          rescue
+            ::Rails::logger.error "** [Opbeat] Error capturing or sending exception #{$!}"
+            ::Rails::logger.debug $!.backtrace.join("\n")
+          end
+
+          render_exception_without_opbeat(env, exception)
+        end
+      end
+    end
+  end
+end
+

data/lib/opbeat/integration/railtie.rb

@@ -0,0 +1,53 @@
+require 'opbeat'
+require 'rails'
+
+module Opbeat
+  class Railtie < Rails::Railtie
+
+    config.opbeat = ActiveSupport::OrderedOptions.new
+    # bootstrap options with the defaults
+    Configuration::DEFAULTS.each { |k,v| config.opbeat[k] = v }
+
+    initializer "opbeat.configure" do |app|
+      config = Configuration.new app.config.opbeat do |conf|
+        conf.logger = Rails.logger
+        conf.view_paths = app.config.paths['app/views'].existent
+      end
+
+      if config.enabled_environments.include?(Rails.env)
+        if Opbeat.start!(config)
+          app.config.middleware.insert 0, Middleware
+          Rails.logger.info "** [Opbeat] Client running"
+        else
+          # :nocov:
+          Rails.logger.info "** [Opbeat] Failed to start"
+          # :nocov:
+        end
+      else
+        # :nocov:
+        Rails.logger.info "** [Opbeat] Disabled in #{Rails.env} environment"
+        # :nocov:
+      end
+    end
+
+    config.after_initialize do
+      # :nocov:
+      require 'opbeat/integration/rails/inject_exceptions_catcher'
+      if defined?(ActionDispatch::DebugExceptions)
+        ActionDispatch::DebugExceptions.send(
+          :include, Opbeat::Integration::Rails::InjectExceptionsCatcher)
+      elsif defined?(::ActionDispatch::ShowExceptions)
+        ::ActionDispatch::ShowExceptions.send(
+          :include, Opbeat::Integration::Rails::InjectExceptionsCatcher)
+      end
+      # :nocov:
+    end
+
+    rake_tasks do
+      # :nocov:
+      require 'opbeat/tasks'
+      # :nocov:
+    end
+
+  end
+end

data/lib/opbeat/integration/resque.rb

@@ -0,0 +1,16 @@
+begin
+  require 'resque'
+rescue LoadError
+end
+
+if defined? Resque
+  module Opbeat
+    module Integration
+      class Resque < Resque::Failure::Base
+        def save
+          Opbeat.report exception
+        end
+      end
+    end
+  end
+end

data/lib/opbeat/integration/sidekiq.rb

@@ -0,0 +1,38 @@
+begin
+  require 'sidekiq'
+rescue LoadError
+end
+
+if defined? Sidekiq
+  module Opbeat
+    module Integration
+      class Sidekiq
+        def call worker, msg, queue
+          begin
+            yield
+          rescue Exception => exception
+            if [Interrupt, SystemExit, SignalException].include? exception.class
+              raise exception
+            end
+
+            Opbeat.report exception
+
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  Sidekiq.configure_server do |config|
+    if Sidekiq::VERSION.to_i < 3
+      config.server_middleware do |chain|
+        chain.add Opbeat::Integration::Sidekiq
+      end
+    else
+      config.error_handlers << lambda do |exception|
+        Opbeat.report exception
+      end
+    end
+  end
+end

data/lib/opbeat/line_cache.rb

@@ -0,0 +1,21 @@
+module Opbeat
+  # @api private
+  class LineCache
+
+    CACHE = {}
+
+    def self.all path
+      CACHE[path] ||= begin
+        File.readlines(path)
+      rescue
+        []
+      end
+    end
+
+    def self.find path, line
+      return nil if line < 1
+      all(path)[line - 1]
+    end
+
+  end
+end

data/lib/opbeat/logging.rb

@@ -0,0 +1,37 @@
+module Opbeat
+  # @api private
+  module Logging
+    PREFIX = "** [Opbeat] ".freeze
+
+    def debug *args, &block
+      config.logger.debug(log_message(*args, &block)) if has_logger?
+    end
+
+    def info *args, &block
+      config.logger.info(log_message(*args, &block)) if has_logger?
+    end
+
+    def warn *args, &block
+      config.logger.warn(log_message(*args, &block)) if has_logger?
+    end
+
+    def error *args, &block
+      config.logger.error(log_message(*args, &block)) if has_logger?
+    end
+
+    def fatal *args, &block
+      config.logger.fatal(log_message(*args, &block)) if has_logger?
+    end
+
+    private
+
+    def has_logger?
+      respond_to?(:config) && config && config.logger
+    end
+
+    def log_message *args, &block
+      msg = block_given? && block.call || args.first
+      "#{PREFIX}#{msg}"
+    end
+  end
+end

data/lib/opbeat/middleware.rb

@@ -0,0 +1,59 @@
+module Opbeat
+  class Middleware
+    def initialize app
+      @app = app
+    end
+
+    def call env
+      begin
+        transaction = Opbeat.transaction "Rack", "app.rack.request"
+        resp = @app.call env
+        resp[2] = BodyProxy.new(resp[2]) { transaction.submit(resp[0]) } if transaction
+      rescue Error
+        raise # Don't report Opbeat errors
+      rescue Exception => e
+        Opbeat.report e, rack_env: env
+        transaction.submit(500) if transaction
+        raise
+      ensure
+        transaction.release if transaction
+      end
+
+      if error = env['rack.exception'] || env['sinatra.error']
+        Opbeat.report error, rack_env: env
+      end
+
+      resp
+    end
+  end
+
+  class BodyProxy
+    def initialize body, &block
+      @body, @block, @closed = body, block, false
+    end
+
+    def respond_to? *args
+      super || @body.respond_to?(*args)
+    end
+
+    def close
+      return if closed?
+
+      @closed = true
+
+      begin
+        @body.close if @body.respond_to?(:close)
+      ensure
+        @block.call
+      end
+    end
+
+    def closed?
+      @closed
+    end
+
+    def method_missing *args, &block
+      @body.__send__(*args, &block)
+    end
+  end
+end