kuende-opbeat 2.0.1

data/lib/opbeat/configuration.rb

@@ -0,0 +1,90 @@
+module Opbeat
+  class Configuration
+
+    # Base URL of the Opbeat server
+    attr_accessor :server
+
+    # Secret access token for authentication with Opbeat
+    attr_accessor :secret_token
+
+    # Organization ID to use with Opbeat
+    attr_accessor :organization_id
+
+    # App ID to use with Opbeat
+    attr_accessor :app_id
+
+    # Logger to use internally
+    attr_accessor :logger
+
+    # Number of lines of code context to capture, or nil for none
+    attr_accessor :context_lines
+
+    # Whitelist of environments that will send notifications to Opbeat
+    attr_accessor :environments
+
+    # Which exceptions should never be sent
+    attr_accessor :excluded_exceptions
+
+    # An array of parameters whould should be filtered from the log
+    attr_accessor :filter_parameters
+
+    # Timeout when waiting for the server to return data in seconds
+    attr_accessor :timeout
+
+    # Timout when opening connection to the server
+    attr_accessor :open_timeout
+
+    # Backoff multipler
+    attr_accessor :backoff_multiplier
+
+    # Should the SSL certificate of the server be verified?
+    attr_accessor :ssl_verification
+
+    attr_reader :current_environment
+
+    attr_accessor :user_controller_method
+
+    # Optional Proc to be used to send events asynchronously
+    attr_reader :async
+
+    def initialize
+      self.server = ENV['OPBEAT_SERVER'] || "https://intake.opbeat.com"
+      self.secret_token = ENV['OPBEAT_SECRET_TOKEN'] if ENV['OPBEAT_SECRET_TOKEN']
+      self.organization_id = ENV['OPBEAT_ORGANIZATION_ID'] if ENV['OPBEAT_ORGANIZATION_ID']
+      self.app_id = ENV['OPBEAT_APP_ID'] if ENV['OPBEAT_APP_ID']
+      @context_lines = 3
+      self.environments = %w[ development production default ]
+      self.current_environment = (defined?(::Rails) && ::Rails.env) || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
+      self.excluded_exceptions = []
+      self.timeout = 1
+      self.open_timeout = 1
+      self.backoff_multiplier = 2
+      self.ssl_verification = true
+      self.user_controller_method = 'current_user'
+      self.async = false
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    def current_environment=(environment)
+      @current_environment = environment.to_s
+    end
+
+    def send_in_current_environment?
+      environments.include? current_environment
+    end
+
+    def async=(value)
+      raise ArgumentError.new("async must be callable (or false to disable)") unless (value == false || value.respond_to?(:call))
+      @async = value
+    end
+
+    alias_method :async?, :async
+
+  end
+end

data/lib/opbeat/error.rb

@@ -0,0 +1,6 @@
+module Opbeat
+
+  class Error < StandardError
+  end
+
+end

data/lib/opbeat/event.rb

@@ -0,0 +1,223 @@
+require 'rubygems'
+require 'socket'
+
+require 'opbeat/error'
+require 'opbeat/linecache'
+
+module Opbeat
+
+  class Event
+
+    LOG_LEVELS = {
+      "debug" => "debug",
+      "info" => "info",
+      "warn" => "warn",
+      "warning" => "warn",
+      "error" => "error",
+    }
+
+    BACKTRACE_RE = /^(.+?):(\d+)(?::in `(.+?)')?$/
+
+    attr_reader :id
+    attr_accessor :organization, :app, :message, :timestamp, :level
+    attr_accessor :logger, :culprit, :hostname, :modules, :extra, :user
+    attr_accessor :environment
+
+    def initialize(options={}, configuration=nil, &block)
+      @configuration = configuration || Opbeat.configuration
+      @interfaces = {}
+
+      @id = options[:id]
+      @message = options[:message]
+      @timestamp = options[:timestamp] || Time.now.utc
+      @level = options[:level] || :error
+      @logger = options[:logger] || 'root'
+      @culprit = options[:culprit]
+      @environment = @configuration[:current_environment]
+      @extra = options[:extra]
+      @user = options[:user]
+
+      # Try to resolve the hostname to an FQDN, but fall back to whatever the load name is
+      hostname = Socket.gethostname
+      hostname = Socket.gethostbyname(hostname).first rescue hostname
+      @hostname = options[:hostname] || hostname
+
+      block.call(self) if block
+
+      # Some type coercion
+      @timestamp = @timestamp.strftime('%Y-%m-%dT%H:%M:%S') if @timestamp.is_a?(Time)
+      @level = LOG_LEVELS[@level.to_s.downcase] if @level.is_a?(String) || @level.is_a?(Symbol)
+
+      # Basic sanity checking
+      raise Error.new('A message is required for all events') unless @message && !@message.empty?
+      raise Error.new('A timestamp is required for all events') unless @timestamp
+    end
+
+    def interface(name, value=nil, &block)
+      int = Opbeat::find_interface(name)
+      Opbeat.logger.info "Unknown interface: #{name}" unless int
+      raise Error.new("Unknown interface: #{name}") unless int
+      @interfaces[int.name] = int.new(value, &block) if value || block
+      @interfaces[int.name]
+    end
+
+    def [](key)
+      interface(key)
+    end
+
+    def []=(key, value)
+      interface(key, value)
+    end
+
+    def to_hash
+      data = {
+        'message' => self.message,
+        'timestamp' => self.timestamp,
+        'level' => self.level,
+        'logger' => self.logger,
+      }
+      data['client_supplied_id'] = self.id if self.id
+      data['culprit'] = self.culprit if self.culprit
+      data['machine'] = {'hostname' => self.hostname } if self.hostname
+      data['environment'] = self.environment if self.environment # Future proofing: Environment is currently not used by the Opbeat API
+      data['extra'] = self.extra || {}
+      data['extra']['ruby'] = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}" unless data['extra']['ruby']
+      data['extra']['rails'] = ::Rails::VERSION::STRING if defined?(::Rails::VERSION::STRING) && !data['extra']['rails']
+      if self.user
+        data['user'] = self.user
+        if self.user[:id] or self.user[:email] or self.user[:username]
+          data['user'][:is_authenticated] = true
+        end
+        data['user'][:is_authenticated] = false if !data['user'][:is_authenticated]
+      end
+      @interfaces.each_pair do |name, int_data|
+        data[name] = int_data.to_hash
+      end
+      data
+    end
+
+    def self.from_exception(exc, options={}, &block)
+      configuration = Opbeat.configuration
+      if exc.is_a?(Opbeat::Error)
+        # Try to prevent error reporting loops
+        Opbeat.logger.info "Refusing to capture Opbeat error: #{exc.inspect}"
+        return nil
+      end
+      if configuration[:excluded_exceptions].include? exc.class.name
+        Opbeat.logger.info "User excluded error: #{exc.inspect}"
+        return nil
+      end
+      options = self.merge_context(options)
+      self.new(options, configuration) do |evt|
+        evt.message = "#{exc.class.to_s}: #{exc.message}"
+        evt.level = :error
+        evt.parse_exception(exc)
+        evt.interface :stack_trace do |int|
+          int.frames = exc.backtrace.reverse.map do |trace_line|
+            int.frame {|frame| evt.parse_backtrace_line(trace_line, frame) }
+          end
+          evt.culprit = evt.get_culprit(int.frames)
+        end
+        block.call(evt) if block
+      end
+    end
+
+    def self.from_rack_exception(exc, rack_env, options={}, &block)
+      from_exception(exc, options) do |evt|
+        evt.interface :http do |int|
+          int.from_rack(rack_env)
+        end
+
+        if not evt.user
+          controller = rack_env["action_controller.instance"]
+          user_method_name = Opbeat.configuration.user_controller_method
+          if controller and controller.respond_to? user_method_name
+            user_obj = controller.send user_method_name
+            evt.from_user_object(user_obj)
+          end
+        end        
+
+        block.call(evt) if block
+      end
+    end
+
+    def self.from_message(message, stack, options={})
+      configuration = Opbeat.configuration
+      options = self.merge_context(options)
+      self.new(options, configuration) do |evt|
+        evt.message = message
+        evt.level = :error
+        evt.interface :message do |int|
+          int.message = message
+        end
+        evt.interface :stack_trace do |int|
+          int.frames = stack.reverse.map do |trace_line|
+            int.frame {|frame| evt.parse_backtrace_line(trace_line, frame) }
+          end
+        end
+      end
+    end
+
+    def self.set_context(options={})
+      Thread.current["_opbeat_context"] = options
+    end
+
+    def get_culprit(frames)
+        lastframe = frames[-2]
+        "#{lastframe.filename} in #{lastframe.function}" if lastframe
+    end
+
+    def parse_exception(exception)
+      interface(:exception) do |int|
+        int.type = exception.class.to_s
+        int.value = exception.message
+        int.module = exception.class.to_s.split('::')[0...-1].join('::')
+      end
+    end
+
+    def parse_backtrace_line(line, frame)
+      md = BACKTRACE_RE.match(line)
+      raise Error.new("Unable to parse backtrace line: #{line.inspect}") unless md
+      frame.abs_path = md[1]
+      frame.lineno = md[2].to_i
+      frame.function = md[3] if md[3]
+      frame.filename = strip_load_path_from(frame.abs_path)
+      if context_lines = @configuration[:context_lines]
+        frame.pre_context, frame.context_line, frame.post_context = \
+          get_contextlines(frame.abs_path, frame.lineno, context_lines)
+      end
+      frame
+    end
+
+    def from_user_object(user_obj)
+      @user = {} if not @user
+      @user[:id] = user_obj.send(:id) rescue nil
+      @user[:email] = user_obj.send(:email) rescue nil
+      @user[:username] = user_obj.send(:username) rescue nil
+    end
+
+    private
+
+    def self.merge_context(options={})
+      context_options = Thread.current["_opbeat_context"] || {}
+      context_options.merge(options)
+    end
+
+
+    # Because linecache can go to hell
+    def self._source_lines(path, from, to)
+    end
+
+    def get_contextlines(path, line, context)
+      lines = (2 * context + 1).times.map do |i|
+        Opbeat::LineCache::getline(path, line - context + i)
+      end
+      [lines[0..(context-1)], lines[context], lines[(context+1)..-1]]
+    end
+
+    def strip_load_path_from(path)
+      prefix = $:.select {|s| path.start_with?(s.to_s)}.sort_by {|s| s.to_s.length}.last
+      prefix ? path[prefix.to_s.chomp(File::SEPARATOR).length+1..-1] : path
+    end
+  end
+end

data/lib/opbeat/filter.rb

@@ -0,0 +1,63 @@
+module Opbeat
+  class Filter
+    MASK = '[FILTERED]'
+    DEFAULT_FILTER = [/(authorization|password|passwd|secret)/i]
+
+    def initialize(filters=nil)
+      if defined?(::Rails)
+        rails_filters = ::Rails.application.config.filter_parameters
+        rails_filters = nil if rails_filters.count == 0
+      end
+      @filters = filters || rails_filters || DEFAULT_FILTER
+    end
+
+    def apply(value, key=nil, &block)
+      if value.is_a?(Hash)
+        value.each.inject({}) do |memo, (k, v)|
+          memo[k] = apply(v, k, &block)
+          memo
+        end
+      elsif value.is_a?(Array)
+        value.map do |value|
+          apply(value, key, &block)
+        end
+      else
+        block.call(key, value)
+      end
+    end
+
+    def sanitize(key, value)
+      if !value.is_a?(String) || value.empty?
+        value
+      elsif @filters.any? { |filter| filter.is_a?(Regexp) ? filter.match(key) : filter.to_s == key.to_s }
+        MASK
+      else
+        value
+      end
+    end
+
+    def process_event_hash(data)
+      return data unless data.has_key? 'http'
+      if data['http'].has_key? 'data'
+        data['http']['data'] = process_hash(data['http']['data'])
+      end
+      if data['http'].has_key? 'query_string'
+        data['http']['query_string'] = process_string(data['http']['query_string'], '&')
+      end
+      if data['http'].has_key? 'cookies'
+        data['http']['cookies'] = process_string(data['http']['cookies'], ';')
+      end
+      data
+    end
+
+    def process_hash(data)
+      apply(data) do |key, value|
+        sanitize(key, value)
+      end
+    end
+
+    def process_string(str, separator='&')
+      str.split(separator).map { |s| s.split('=') }.map { |a| a[0]+'='+sanitize(a[0], a[1]) }.join(separator)
+    end
+  end
+end

data/lib/opbeat/integrations/delayed_job.rb

@@ -0,0 +1,32 @@
+begin
+  require 'delayed_job'
+rescue LoadError
+end
+
+# Based on the Sentry equivalent.
+if defined?(Delayed)
+
+  module Delayed
+    module Plugins
+      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 Exception => exception
+              # Log error to Opbeat
+              ::Opbeat.capture_exception(exception)
+              # Make sure we propagate the failure!
+              raise exception
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Register DelayedJob Opbeat plugin
+  Delayed::Worker.plugins << Delayed::Plugins::Opbeat
+end

data/lib/opbeat/integrations/resque.rb

@@ -0,0 +1,22 @@
+begin
+  require 'resque'
+rescue LoadError
+end
+
+if defined?(Resque)
+
+  module Resque
+    module Failure
+      # Failure backend for Opbeat
+      class Opbeat < Base
+        # @override (see Resque::Failure::Base#save)
+        # @param (see Resque::Failure::Base#save)
+        # @return (see Resque::Failure::Base#save)
+        def save
+          ::Opbeat.capture_exception(exception)
+        end
+      end
+    end
+  end
+  
+end

data/lib/opbeat/integrations/sidekiq.rb

@@ -0,0 +1,32 @@
+begin
+  require 'sidekiq'
+rescue LoadError
+end
+
+if defined? Sidekiq
+  module Opbeat
+    module Integrations
+      class Sidekiq
+        def call(worker, msg, queue)
+          begin
+            yield
+          rescue Exception => ex
+            raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
+            ::Opbeat.capture_exception(ex)
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  ::Sidekiq.configure_server do |config|
+    if ::Sidekiq::VERSION < '3'
+      config.server_middleware do |chain|
+        chain.add ::Opbeat::Integrations::Sidekiq
+      end
+    else
+      config.error_handlers << Proc.new { |ex, ctx| ::Opbeat.capture_exception(ex) }
+    end
+  end
+end