opbeat 2.0.0 → 3.0.0

data/Rakefile

@@ -1,19 +1,25 @@
-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
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
 end
-
 task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+task :mem_profile do
+  require 'memory_profiler'
+  $:.unshift Dir.pwd + '/lib'
+
+  filename = "profile-#{Time.now.to_i}.txt"
+
+  MemoryProfiler.report(allow_files: /opbeat/i) do
+    require 'opbeat'
+  end.pretty_print(to_file: filename)
+
+  filename
+end

data/gemfiles/Gemfile.base

@@ -0,0 +1,28 @@
+source "http://rubygems.org"
+
+gemspec path: File.expand_path('../..', __FILE__)
+
+gem 'rake'
+gem 'rspec'
+gem 'timecop'
+gem 'webmock'
+gem 'rack-test'
+
+gem 'yard'
+gem 'simplecov'
+
+# external libs
+
+gem 'sinatra'
+gem 'redis'
+gem 'fakeredis'
+gem 'sqlite3'
+gem 'sequel'
+
+gem 'delayed_job', require: false
+gem 'resque', require: false
+
+unless RUBY_VERSION.to_i <= 1
+  gem 'sidekiq', require: false
+end
+

data/gemfiles/Gemfile.rails-3.2.x

@@ -0,0 +1,3 @@
+eval_gemfile File.expand_path('../Gemfile.base', __FILE__)
+
+gem 'rails', '~> 3.2.0'

data/gemfiles/Gemfile.rails-4.0.x

@@ -0,0 +1,3 @@
+eval_gemfile File.expand_path('../Gemfile.base', __FILE__)
+
+gem 'rails', '~> 4.0.0'

data/gemfiles/Gemfile.rails-4.1.x

@@ -0,0 +1,3 @@
+eval_gemfile File.expand_path('../Gemfile.base', __FILE__)
+
+gem 'rails', '~> 4.1.0'

data/gemfiles/Gemfile.rails-4.2.x

@@ -0,0 +1,3 @@
+eval_gemfile File.expand_path('../Gemfile.base', __FILE__)
+
+gem 'rails', '~> 4.2.0'

data/lib/opbeat.rb

@@ -1,121 +1,141 @@
 require 'opbeat/version'
 require 'opbeat/configuration'
-require 'opbeat/logger'
+
+require 'opbeat/logging'
 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/error'
+require 'opbeat/trace_helpers'
+
+require 'opbeat/middleware'
 
-require 'opbeat/integrations/delayed_job'
-require 'opbeat/integrations/sidekiq'
+require 'opbeat/integration/railtie' if defined?(Rails)
 
-require 'opbeat/railtie' if defined?(::Rails::Railtie)
+require 'opbeat/injections'
+require 'opbeat/injections/net_http'
+require 'opbeat/injections/redis'
+require 'opbeat/injections/sinatra'
+require 'opbeat/injections/sequel'
 
+require 'opbeat/integration/delayed_job'
+require 'opbeat/integration/sidekiq'
+require 'opbeat/integration/resque'
 
 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
+  # Start the Opbeat client
+  #
+  # @param conf [Configuration] An Configuration object
+  def self.start! conf
+    Client.start! conf
+  end
 
-    # A Opbeat configuration object. Must act like a hash and return sensible
-    # values for all Opbeat configuration options. See Opbeat::Configuration.
-    attr_writer :configuration
+  # Stop the Opbeat client
+  def self.stop!
+    Client.stop!
+  end
 
-    def logger
-      @logger ||= Logger.new
-    end
+  def self.started?
+    !!Client.inst
+  end
 
-    # Tell the log that the client is good to go
-    def report_ready
-      self.logger.info "Opbeat #{VERSION} ready to catch errors"
+  # Start a new transaction or return the currently running
+  #
+  # @param endpoint [String] A description of the transaction, eg `ExamplesController#index`
+  # @param kind [String] The kind of the transaction, eg `app.request.get` or `db.mysql2.query`
+  # @param result [Object] Result of the transaction, eq `200` for a HTTP server
+  # @yield [Transaction] Optional block encapsulating transaction
+  # @return [Transaction] Unless block given
+  def self.transaction endpoint, kind = nil, result = nil, &block
+    unless client
+      return yield if block_given?
+      return nil
     end
 
-    # The configuration object.
-    # @see Opbeat.configure
-    def configuration
-      @configuration ||= Configuration.new
-    end
+    client.transaction endpoint, kind, result, &block
+  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
+  # Starts a new trace under the current Transaction
+  #
+  # @param signature [String] A description of the trace, eq `SELECT FROM "users"`
+  # @param kind [String] The kind of trace, eq `db.mysql2.query`
+  # @param extra [Hash] Extra information about the trace
+  # @yield [Trace] Optional block encapsulating trace
+  # @return [Trace] Unless block given
+  def self.trace signature, kind = nil, extra = nil, &block
+    unless client
+      return yield if block_given?
+      return nil
     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
+    client.trace signature, kind, extra, &block
+  end
+
+  def self.flush_transactions
+    unless client
+      return yield if block_given?
+      return nil
     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
+    client.flush_transactions
+  end
+
+  # Send an exception to Opbeat
+  #
+  # @param exception [Exception]
+  # @param opts [Hash]
+  # @option opts [Hash] :rack_env A rack env object
+  # @return [Net::HTTPResponse]
+  def self.report exception, opts = {}
+    unless client
+      return yield if block_given?
+      return nil
     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
+    client.report exception, opts
+  end
+
+  # Send an exception to Opbeat
+  #
+  # @param message [String]
+  # @param opts [Hash]
+  # @return [Net::HTTPResponse]
+  def self.report_message message, opts = {}
+    unless client
+      return yield if block_given?
+      return nil
     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
+    client.report_message message, opts
+  end
+
+  # Captures any exceptions raised inside the block
+  #
+  def self.capture &block
+    unless client
+      return yield if block_given?
+      return nil
     end
 
-    def set_context(options={})
-      Event.set_context(options)
+    client.capture(&block)
+  end
+
+  # Notify Opbeat of a release
+  #
+  # @param rel [Hash]
+  # @option rel [String] :rev Revision
+  # @option rel [String] :branch
+  # @return [Net::HTTPResponse]
+  def self.release rel, opts = {}
+    unless client
+      return yield if block_given?
+      return nil
     end
 
-    alias :captureException :capture_exception
-    alias :captureMessage :capture_message
+    client.release rel, opts
+  end
+
+  private
+
+  def self.client
+    Client.inst
   end
 end

data/lib/opbeat/capistrano.rb

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

data/lib/opbeat/client.rb

@@ -1,122 +1,283 @@
-require 'openssl'
-require 'uri'
-require 'multi_json'
-require 'faraday'
-
-require 'opbeat/version'
-require 'opbeat/error'
-require 'opbeat/filter'
+require 'thread'
+require 'opbeat/subscriber'
+require 'opbeat/http_client'
+require 'opbeat/worker'
+require 'opbeat/transaction'
+require 'opbeat/trace'
+require 'opbeat/error_message'
+require 'opbeat/data_builders'
 
 module Opbeat
+  # @api private
+  class Client
+    include Logging
+
+    KEY = :__opbeat_transaction_key
+    LOCK = Mutex.new
 
-  class ClientState
-    def initialize(configuration)
-      @configuration = configuration
-      @retry_number = 0
-      @last_check = Time.now
+    class TransactionInfo
+      def current
+        Thread.current[KEY]
+      end
+      def current= transaction
+        Thread.current[KEY] = transaction
+      end
     end
 
-    def should_try?
-      return true if @status == :online
+    # life cycle
 
-      interval = ([@retry_number, 6].min() ** 2) * @configuration[:backoff_multiplier]
-      return true if Time.now - @last_check > interval
+    def self.inst
+      @instance
+    end
 
-      false
+    def self.start! config = nil
+      return @instance if @instance
+
+      LOCK.synchronize do
+        return @instance if @instance
+        @instance = new(config).start!
+      end
     end
 
-    def set_fail
-      @status = :error
-      @retry_number += 1
-      @last_check = Time.now
+    def self.stop!
+      LOCK.synchronize do
+        return unless @instance
+
+        @instance.stop!
+        @instance = nil
+      end
     end
 
-    def set_success
-      @status = :online
-      @retry_number = 0
-      @last_check = nil
+    def initialize config
+      @config = config
+
+      @http_client = HttpClient.new config
+      @queue = Queue.new
+
+      @data_builders = Struct.new(:transactions, :error_message).new(
+        DataBuilders::Transactions.new(config),
+        DataBuilders::Error.new(config)
+      )
+
+      unless config.disable_performance
+        @transaction_info = TransactionInfo.new
+        @subscriber = Subscriber.new config, self
+      end
+
+      @pending_transactions = []
+      @last_sent_transactions = Time.now.utc
     end
-  end
 
-  class Client
+    attr_reader :config, :queue, :pending_transactions
 
-    USER_AGENT = "opbeat-ruby/#{Opbeat::VERSION}"
+    def start!
+      info "Starting client"
 
-    attr_accessor :configuration
-    attr_accessor :state
+      @subscriber.register! if @subscriber
 
-    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
+      self
+    end
 
-      @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
+    def stop!
+      flush_transactions
+      kill_worker
+      unregister! if @subscriber
     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
+    at_exit do
+      stop!
+    end
+
+    # metrics
+
+    def current_transaction
+      @transaction_info.current
     end
 
-    def encode(event)
-      event_hash = event.to_hash
-      event_hash = @filter.process_event_hash(event_hash)
-      return MultiJson.encode(event_hash)
+    def current_transaction= transaction
+      @transaction_info.current = transaction
     end
 
-    def send(url_postfix, message)
+    def transaction endpoint, kind = nil, result = nil, &block
+      if config.disable_performance
+        return yield if block_given?
+        return nil
+      end
+
+      if transaction = current_transaction
+        yield transaction if block_given?
+        return transaction
+      end
+
+      transaction = Transaction.new self, endpoint, kind, result
+
+      self.current_transaction = transaction
+      return transaction unless block_given?
+
       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
+        yield transaction
+
+      ensure
+        self.current_transaction = nil
+        transaction.done
+      end
+
+      transaction
+    end
+
+    def trace *args, &block
+      if config.disable_performance
+        return yield if block_given?
+        return nil
+      end
+
+      unless transaction = current_transaction
+        return yield if block_given?
+        return
+      end
+
+      transaction.trace(*args, &block)
+    end
+
+    def submit_transaction transaction
+      ensure_worker_running
+
+      if config.debug_traces
+        unless transaction.endpoint == 'Rack'
+          debug { Util::Inspector.new.transaction transaction, include_parents: true }
         end
-        unless response.status.between?(200, 299)
-          raise Error.new("Error from Opbeat server (#{response.status}): #{response.body}")
+      end
+
+      @pending_transactions << transaction
+
+      if should_send_transactions?
+        flush_transactions
+      end
+    end
+
+    def flush_transactions
+      return if @pending_transactions.empty?
+
+      data = @data_builders.transactions.build(@pending_transactions)
+      enqueue Worker::PostRequest.new('/transactions/', data)
+
+      @last_sent_transactions = Time.now.utc
+      @pending_transactions = []
+
+      true
+    end
+
+    # errors
+
+    def report exception, opts = {}
+      return if config.disable_errors
+      return unless exception
+
+      unless exception.backtrace
+        exception.set_backtrace caller
+      end
+
+      error_message = ErrorMessage.from_exception(config, exception, opts)
+      data = @data_builders.error_message.build error_message
+      enqueue Worker::PostRequest.new('/errors/', data)
+    end
+
+    def report_message message, opts = {}
+      return if config.disable_errors
+
+      error_message = ErrorMessage.new(config, message, opts)
+      data = @data_builders.error_message.build error_message
+      enqueue Worker::PostRequest.new('/errors/', data)
+    end
+
+    def capture &block
+      unless block_given?
+        return Kernel.at_exit do
+          if $!
+            debug $!.inspect
+            report $!
+          end
         end
-      rescue
-        @state.set_fail
+      end
+
+      begin
+        yield
+      rescue Error => e
+        raise # Don't capture Opbeat errors
+      rescue Exception => e
+        report e
         raise
       end
+    end
 
-      @state.set_success
-      response
+    # releases
+
+    def release rel, opts = {}
+      rev = rel[:rev]
+      if opts[:inline]
+        debug "Sending release #{rev}"
+        @http_client.post '/releases/', rel
+      else
+        debug "Enqueuing release #{rev}"
+        enqueue Worker::PostRequest.new('/releases/', rel)
+      end
+    end
+
+    private
+
+    def enqueue request
+      @queue << request
     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."
+    def start_worker
+      return if worker_running?
+
+      if config.disable_worker
         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
+      info "Starting worker in thread"
+
+      @worker_thread = Thread.new do
+        begin
+          Worker.new(config, @queue, @http_client).run
+        rescue => e
+          fatal "Failed booting worker:\n#{e.inspect}"
+          debug e.backtrace.join("\n")
+          raise
+        end
       end
-      response
     end
 
-    def send_release(release)
-      Opbeat.logger.debug "Sending release to Opbeat"
-      send("/releases/", release)
+    def kill_worker
+      return unless worker_running?
+      @queue << Worker::StopMessage.new
+      @worker_thread.join 1
+      @worker_thread = nil
     end
-  end
 
+    def ensure_worker_running
+      return if worker_running?
+
+      LOCK.synchronize do
+        return if worker_running?
+        start_worker
+      end
+    end
+
+    def worker_running?
+      @worker_thread && @worker_thread.alive?
+    end
+
+    def unregister!
+      @subscriber.unregister!
+    end
+
+    def should_send_transactions?
+      return true if config.transaction_post_interval.nil?
+
+      Time.now.utc - @last_sent_transactions > config.transaction_post_interval
+    end
+
+  end
 end