alec-gem 2.7.2

data/exe/raven

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require "raven"
+require "raven/cli"
+require "optparse"
+
+parser = OptionParser.new do |opt|
+  opt.banner = "Usage: raven COMMAND [OPTIONS]"
+  opt.separator  ""
+  opt.separator  "Commands"
+  opt.separator  "     test: send a test event"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  opt.on("-h", "--help", "help") do
+    puts parser
+  end
+end
+
+parser.parse!
+
+case ARGV[0]
+when "test"
+  dsn = ARGV[1] if ARGV.length > 1
+  if !dsn
+    puts "Usage: raven test <dsn>"
+  else
+    Raven::CLI.test(dsn)
+  end
+else
+  puts parser
+end

data/lib/raven.rb

@@ -0,0 +1,3 @@
+require 'raven/base'
+
+Raven.inject

data/lib/raven/backtrace.rb

@@ -0,0 +1,137 @@
+## Inspired by Rails' and Airbrake's backtrace parsers.
+
+module Raven
+  # Front end to parsing the backtrace for each notice
+  class Backtrace
+    # Handles backtrace parsing line by line
+    class Line
+      RB_EXTENSION = ".rb".freeze
+      # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
+      RUBY_INPUT_FORMAT = /
+        ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
+        (\d+)
+        (?: :in \s `([^']+)')?$
+      /x
+
+      # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
+      JAVA_INPUT_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # The module name (JRuby)
+      attr_reader :module_name
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line)
+        ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
+        if ruby_match
+          _, file, number, method = ruby_match.to_a
+          file.sub!(/\.class$/, RB_EXTENSION)
+          module_name = nil
+        else
+          java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
+          _, module_name, method, file, number = java_match.to_a
+        end
+        new(file, number, method, module_name)
+      end
+
+      def initialize(file, number, method, module_name)
+        self.file = file
+        self.module_name = module_name
+        self.number = number.to_i
+        self.method = method
+      end
+
+      def in_app
+        if file =~ self.class.in_app_pattern
+          true
+        else
+          false
+        end
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{self}>"
+      end
+
+      def self.in_app_pattern
+        @in_app_pattern ||= begin
+          project_root = Raven.configuration.project_root && Raven.configuration.project_root.to_s
+          Regexp.new("^(#{project_root}/)?#{Raven.configuration.app_dirs_pattern || APP_DIRS_PATTERN}")
+        end
+      end
+
+      private
+
+      attr_writer :file, :number, :method, :module_name
+    end
+
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test)/
+
+    # holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+
+    def self.parse(backtrace, opts = {})
+      ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
+
+      filters = opts[:filters] || []
+      filtered_lines = ruby_lines.to_a.map do |line|
+        filters.reduce(line) do |nested_line, proc|
+          proc.call(nested_line)
+        end
+      end.compact
+
+      lines = filtered_lines.map do |unparsed_line|
+        Line.parse(unparsed_line)
+      end
+
+      new(lines)
+    end
+
+    def initialize(lines)
+      self.lines = lines
+    end
+
+    def inspect
+      "<Backtrace: " + lines.map(&:inspect).join(", ") + ">"
+    end
+
+    def to_s
+      content = []
+      lines.each do |line|
+        content << line
+      end
+      content.join("\n")
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_writer :lines
+  end
+end

data/lib/raven/base.rb

@@ -0,0 +1,106 @@
+require 'raven/version'
+require 'raven/backtrace'
+require 'raven/breadcrumbs'
+require 'raven/processor'
+require 'raven/processor/sanitizedata'
+require 'raven/processor/removecircularreferences'
+require 'raven/processor/utf8conversion'
+require 'raven/processor/cookies'
+require 'raven/processor/post_data'
+require 'raven/processor/http_headers'
+require 'raven/configuration'
+require 'raven/context'
+require 'raven/client'
+require 'raven/event'
+require 'raven/linecache'
+require 'raven/logger'
+require 'raven/interfaces/message'
+require 'raven/interfaces/exception'
+require 'raven/interfaces/single_exception'
+require 'raven/interfaces/stack_trace'
+require 'raven/interfaces/http'
+require 'raven/transports'
+require 'raven/transports/http'
+require 'raven/utils/deep_merge'
+require 'raven/utils/real_ip'
+require 'raven/instance'
+
+require 'forwardable'
+require 'English'
+
+module Raven
+  AVAILABLE_INTEGRATIONS = %w(delayed_job railties sidekiq rack rack-timeout rake).freeze
+
+  class Error < StandardError
+  end
+
+  class << self
+    extend Forwardable
+
+    def instance
+      @instance ||= Raven::Instance.new
+    end
+
+    def_delegators :instance, :client=, :configuration=, :context, :logger, :configuration,
+                   :client, :report_status, :configure, :send_event, :capture, :capture_type,
+                   :last_event_id, :annotate_exception, :user_context,
+                   :tags_context, :extra_context, :rack_context, :breadcrumbs
+
+    def_delegator :instance, :report_status, :report_ready
+    def_delegator :instance, :capture_type, :capture_message
+    def_delegator :instance, :capture_type, :capture_exception
+    # For cross-language compatibility
+    def_delegator :instance, :capture_type, :captureException
+    def_delegator :instance, :capture_type, :captureMessage
+    def_delegator :instance, :annotate_exception, :annotateException
+    def_delegator :instance, :annotate_exception, :annotate
+
+    # Injects various integrations. Default behavior: inject all available integrations
+    def inject
+      inject_only(*Raven::AVAILABLE_INTEGRATIONS)
+    end
+
+    def inject_without(*exclude_integrations)
+      include_integrations = Raven::AVAILABLE_INTEGRATIONS - exclude_integrations.map(&:to_s)
+      inject_only(*include_integrations)
+    end
+
+    def inject_only(*only_integrations)
+      only_integrations = only_integrations.map(&:to_s)
+      integrations_to_load = Raven::AVAILABLE_INTEGRATIONS & only_integrations
+      not_found_integrations = only_integrations - integrations_to_load
+      if not_found_integrations.any?
+        logger.warn "Integrations do not exist: #{not_found_integrations.join ', '}"
+      end
+      integrations_to_load &= Gem.loaded_specs.keys
+      # TODO(dcramer): integrations should have some additional checks baked-in
+      # or we should break them out into their own repos. Specifically both the
+      # rails and delayed_job checks are not always valid (i.e. Rails 2.3) and
+      # https://github.com/getsentry/raven-ruby/issues/180
+      integrations_to_load.each do |integration|
+        load_integration(integration)
+      end
+    end
+
+    def load_integration(integration)
+      require "raven/integrations/#{integration}"
+    rescue Exception => error
+      logger.warn "Unable to load raven/integrations/#{integration}: #{error}"
+    end
+
+    def safely_prepend(module_name, opts = {})
+      return if opts[:to].nil? || opts[:from].nil?
+      if opts[:to].respond_to?(:prepend, true)
+        opts[:to].send(:prepend, opts[:from].const_get(module_name))
+      else
+        opts[:to].send(:include, opts[:from].const_get("Old" + module_name))
+      end
+    end
+
+    def sys_command(command)
+      result = `#{command} 2>&1` rescue nil
+      return if result.nil? || result.empty? || $CHILD_STATUS.exitstatus != 0
+      result.strip
+    end
+  end
+end

data/lib/raven/breadcrumbs.rb

@@ -0,0 +1,76 @@
+module Raven
+  class Breadcrumb
+    attr_accessor :category, :data, :message, :level, :timestamp, :type
+
+    def initialize
+      @category = nil
+      @data = {}
+      @level = nil
+      @message = nil
+      @timestamp = Time.now.to_i
+      @type = nil
+    end
+
+    def to_hash
+      {
+        :category => @category,
+        :data => @data,
+        :level => @level,
+        :message => @message,
+        :timestamp => @timestamp,
+        :type => @type
+      }
+    end
+  end
+end
+
+module Raven
+  class BreadcrumbBuffer
+    include Enumerable
+
+    attr_accessor :buffer
+
+    def self.current
+      Thread.current[:sentry_breadcrumbs] ||= new
+    end
+
+    def self.clear!
+      Thread.current[:sentry_breadcrumbs] = nil
+    end
+
+    def initialize(size = 100)
+      @buffer = Array.new(size)
+    end
+
+    def record(crumb = nil)
+      if block_given?
+        crumb = Breadcrumb.new if crumb.nil?
+        yield(crumb)
+      end
+      @buffer.slice!(0)
+      @buffer << crumb
+    end
+
+    def members
+      @buffer.compact
+    end
+
+    def peek
+      members.last
+    end
+
+    def each(&block)
+      members.each(&block)
+    end
+
+    def empty?
+      !members.any?
+    end
+
+    def to_hash
+      {
+        :values => members.map(&:to_hash)
+      }
+    end
+  end
+end

data/lib/raven/breadcrumbs/activesupport.rb

@@ -0,0 +1,19 @@
+module Raven
+  module ActiveSupportBreadcrumbs
+    class << self
+        def add(name, started, _finished, _unique_id, data)
+          Raven.breadcrumbs.record do |crumb|
+            crumb.data = data
+            crumb.category = name
+            crumb.timestamp = started.to_i
+          end
+        end
+
+        def inject
+          ActiveSupport::Notifications.subscribe(/.*/) do |name, started, finished, unique_id, data|
+            add(name, started, finished, unique_id, data)
+          end
+        end
+    end
+  end
+end

data/lib/raven/breadcrumbs/logger.rb

@@ -0,0 +1,93 @@
+require 'logger'
+
+module Raven
+  module BreadcrumbLogger
+    LEVELS = {
+      ::Logger::DEBUG => 'debug',
+      ::Logger::INFO  => 'info',
+      ::Logger::WARN  => 'warn',
+      ::Logger::ERROR => 'error',
+      ::Logger::FATAL => 'fatal'
+    }.freeze
+
+    EXC_FORMAT = /^([a-zA-Z0-9]+)\:\s(.*)$/
+
+    def self.parse_exception(message)
+      lines = message.split(/\n\s*/)
+      # TODO: wat
+      return nil unless lines.length > 2
+
+      match = lines[0].match(EXC_FORMAT)
+      return nil unless match
+
+      _, type, value = match.to_a
+      [type, value]
+    end
+
+    def add(*args)
+      add_breadcrumb(*args)
+      super
+    end
+
+    def add_breadcrumb(severity, message = nil, progname = nil)
+      message = progname if message.nil? # see Ruby's Logger docs for why
+      return if ignored_logger?(progname)
+      return if message.nil? || message == ""
+
+      # some loggers will add leading/trailing space as they (incorrectly, mind you)
+      # think of logging as a shortcut to std{out,err}
+      message = message.strip
+
+      last_crumb = Raven.breadcrumbs.peek
+      # try to avoid dupes from logger broadcasts
+      if last_crumb.nil? || last_crumb.message != message
+        error = Raven::BreadcrumbLogger.parse_exception(message)
+        # TODO(dcramer): we need to filter out the "currently captured error"
+        if error
+          Raven.breadcrumbs.record do |crumb|
+            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
+            crumb.category = progname || 'error'
+            crumb.type = 'error'
+            crumb.data = {
+              :type => error[0],
+              :value => error[1]
+            }
+          end
+        else
+          Raven.breadcrumbs.record do |crumb|
+            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
+            crumb.category = progname || 'logger'
+            crumb.message = message
+          end
+        end
+      end
+    end
+
+    private
+
+    def ignored_logger?(progname)
+      progname == "sentry" ||
+        Raven.configuration.exclude_loggers.include?(progname)
+    end
+  end
+  module OldBreadcrumbLogger
+    def self.included(base)
+      base.class_eval do
+        include Raven::BreadcrumbLogger
+        alias_method :add_without_raven, :add
+        alias_method :add, :add_with_raven
+      end
+    end
+
+    def add_with_raven(*args)
+      add_breadcrumb(*args)
+      add_without_raven(*args)
+    end
+  end
+end
+
+Raven.safely_prepend(
+  "BreadcrumbLogger",
+  :from => Raven,
+  :to => ::Logger
+)