RubyGems - opbeat - Versions diffs - 2.0.0 → 3.0.0 - Mend

@@ -1,10 +0,0 @@
-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 DELETED Viewed

@@ -1,10 +0,0 @@
-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 DELETED Viewed

@@ -1,11 +0,0 @@
-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/better_attr_accessor.rb DELETED Viewed

@@ -1,44 +0,0 @@
-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/event.rb DELETED Viewed

@@ -1,223 +0,0 @@
-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/integrations/resque.rb DELETED Viewed

@@ -1,22 +0,0 @@
-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 DELETED Viewed

@@ -1,32 +0,0 @@
-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

data/lib/opbeat/interfaces.rb DELETED Viewed

@@ -1,35 +0,0 @@
-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