alec-gem 2.7.2

data/lib/raven/context.rb

@@ -0,0 +1,43 @@
+require 'rbconfig'
+
+module Raven
+  class Context
+    def self.current
+      Thread.current[:sentry_context] ||= new
+    end
+
+    def self.clear!
+      Thread.current[:sentry_context] = nil
+    end
+
+    attr_accessor :transaction, :extra, :server_os, :rack_env, :runtime, :tags, :user
+
+    def initialize
+      self.server_os = self.class.os_context
+      self.runtime = self.class.runtime_context
+      self.extra = { :server => { :os => server_os, :runtime => runtime } }
+      self.rack_env = nil
+      self.tags = {}
+      self.user = {}
+      self.transaction = []
+    end
+
+    class << self
+      def os_context
+        @os_context ||= {
+          :name => Raven.sys_command("uname -s") || RbConfig::CONFIG["host_os"],
+          :version => Raven.sys_command("uname -v"),
+          :build => Raven.sys_command("uname -r"),
+          :kernel_version => Raven.sys_command("uname -a") || Raven.sys_command("ver") # windows
+        }
+      end
+
+      def runtime_context
+        @runtime_context ||= {
+          :name => RbConfig::CONFIG["ruby_install_name"],
+          :version => Raven.sys_command("ruby -v")
+        }
+      end
+    end
+  end
+end

data/lib/raven/event.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+require 'socket'
+require 'securerandom'
+
+module Raven
+  class Event
+    # See Sentry server default limits at
+    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
+    MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
+
+    SDK = { "name" => "raven-ruby", "version" => Raven::VERSION }.freeze
+
+    attr_accessor :id, :logger, :transaction, :server_name, :release, :modules,
+                  :extra, :tags, :context, :configuration, :checksum,
+                  :fingerprint, :environment, :server_os, :runtime,
+                  :breadcrumbs, :user, :backtrace, :platform, :sdk
+    alias event_id id
+
+    attr_reader :level, :timestamp, :time_spent
+
+    def initialize(init = {})
+      # Set some simple default values
+      self.id            = SecureRandom.uuid.delete("-")
+      self.timestamp     = Time.now.utc
+      self.level         = :error
+      self.logger        = :ruby
+      self.platform      = :ruby
+      self.sdk           = SDK
+
+      # Set some attributes with empty hashes to allow merging
+      @interfaces        = {}
+      self.user          = {} # TODO: contexts
+      self.extra         = {} # TODO: contexts
+      self.server_os     = {} # TODO: contexts
+      self.runtime       = {} # TODO: contexts
+      self.tags          = {} # TODO: contexts
+
+      copy_initial_state
+
+      # Allow attributes to be set on the event at initialization
+      yield self if block_given?
+      init.each_pair { |key, val| public_send("#{key}=", val) }
+
+      set_core_attributes_from_configuration
+      set_core_attributes_from_context
+    end
+
+    def self.from_exception(exc, options = {}, &block)
+      exception_context = if exc.instance_variable_defined?(:@__raven_context)
+                            exc.instance_variable_get(:@__raven_context)
+                          elsif exc.respond_to?(:raven_context)
+                            exc.raven_context
+                          else
+                            {}
+                          end
+      options = Raven::Utils::DeepMergeHash.deep_merge(exception_context, options)
+
+      configuration = options[:configuration] || Raven.configuration
+      return unless configuration.exception_class_allowed?(exc)
+
+      new(options) do |evt|
+        evt.message = "#{exc.class}: #{exc.message}"
+
+        evt.add_exception_interface(exc)
+
+        yield evt if block
+      end
+    end
+
+    def self.from_message(message, options = {})
+      new(options) do |evt|
+        evt.message = message, options[:message_params] || []
+        if options[:backtrace]
+          evt.interface(:stacktrace) do |int|
+            int.frames = evt.stacktrace_interface_from(options[:backtrace])
+          end
+        end
+      end
+    end
+
+    def message
+      @interfaces[:logentry] && @interfaces[:logentry].unformatted_message
+    end
+
+    def message=(args)
+      message, params = *args
+      interface(:message) do |int|
+        int.message = message.byteslice(0...MAX_MESSAGE_SIZE_IN_BYTES) # Messages limited to 10kb
+        int.params = params
+      end
+    end
+
+    def timestamp=(time)
+      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : time
+    end
+
+    def time_spent=(time)
+      @time_spent = time.is_a?(Float) ? (time * 1000).to_i : time
+    end
+
+    def level=(new_level) # needed to meet the Sentry spec
+      @level = new_level == "warn" || new_level == :warn ? :warning : new_level
+    end
+
+    def interface(name, value = nil, &block)
+      int = Interface.registered[name]
+      raise(Error, "Unknown interface: #{name}") unless int
+      @interfaces[int.sentry_alias] = int.new(value, &block) if value || block
+      @interfaces[int.sentry_alias]
+    end
+
+    def [](key)
+      interface(key)
+    end
+
+    def []=(key, value)
+      interface(key, value)
+    end
+
+    def to_hash
+      data = [:checksum, :environment, :event_id, :extra, :fingerprint, :level,
+              :logger, :message, :modules, :platform, :release, :sdk, :server_name,
+              :tags, :time_spent, :timestamp, :transaction, :user].each_with_object({}) do |att, memo|
+        memo[att] = public_send(att) if public_send(att)
+      end
+
+      data[:breadcrumbs] = @breadcrumbs.to_hash unless @breadcrumbs.empty?
+
+      @interfaces.each_pair do |name, int_data|
+        data[name.to_sym] = int_data.to_hash
+      end
+      data
+    end
+
+    def to_json_compatible
+      cleaned_hash = async_json_processors.reduce(to_hash) { |a, e| e.process(a) }
+      JSON.parse(JSON.generate(cleaned_hash))
+    end
+
+    def add_exception_interface(exc)
+      interface(:exception) do |exc_int|
+        exceptions = exception_chain_to_array(exc)
+        backtraces = Set.new
+        exc_int.values = exceptions.map do |e|
+          SingleExceptionInterface.new do |int|
+            int.type = e.class.to_s
+            int.value = e.to_s
+            int.module = e.class.to_s.split('::')[0...-1].join('::')
+
+            int.stacktrace =
+              if e.backtrace && !backtraces.include?(e.backtrace.object_id)
+                backtraces << e.backtrace.object_id
+                StacktraceInterface.new do |stacktrace|
+                  stacktrace.frames = stacktrace_interface_from(e.backtrace)
+                end
+              end
+          end
+        end
+      end
+    end
+
+    def stacktrace_interface_from(backtrace)
+      Backtrace.parse(backtrace).lines.reverse.each_with_object([]) do |line, memo|
+        frame = StacktraceInterface::Frame.new
+        frame.abs_path = line.file if line.file
+        frame.function = line.method if line.method
+        frame.lineno = line.number
+        frame.in_app = line.in_app
+        frame.module = line.module_name if line.module_name
+
+        if configuration[:context_lines] && frame.abs_path
+          frame.pre_context, frame.context_line, frame.post_context = \
+            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration[:context_lines])
+        end
+
+        memo << frame if frame.filename
+      end
+    end
+
+    # For cross-language compat
+    class << self
+      alias captureException from_exception
+      alias captureMessage from_message
+      alias capture_exception from_exception
+      alias capture_message from_message
+    end
+
+    private
+
+    def copy_initial_state
+      self.configuration = Raven.configuration
+      self.breadcrumbs   = Raven.breadcrumbs
+      self.context       = Raven.context
+    end
+
+    def set_core_attributes_from_configuration
+      self.server_name ||= configuration.server_name
+      self.release     ||= configuration.release
+      self.modules       = list_gem_specs if configuration.send_modules
+      self.environment ||= configuration.current_environment
+    end
+
+    def set_core_attributes_from_context
+      self.transaction ||= context.transaction.last
+
+      # If this is a Rack event, merge Rack context
+      add_rack_context if !self[:http] && context.rack_env
+
+      # Merge contexts
+      self.user = context.user.merge(user) # TODO: contexts
+      self.extra = context.extra.merge(extra) # TODO: contexts
+      self.tags = configuration.tags.merge(context.tags).merge!(tags) # TODO: contexts
+    end
+
+    def add_rack_context
+      interface :http do |int|
+        int.from_rack(context.rack_env)
+      end
+      context.user[:ip_address] = calculate_real_ip_from_rack
+    end
+
+    # When behind a proxy (or if the user is using a proxy), we can't use
+    # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
+    def calculate_real_ip_from_rack
+      Utils::RealIp.new(
+        :remote_addr => context.rack_env["REMOTE_ADDR"],
+        :client_ip => context.rack_env["HTTP_CLIENT_IP"],
+        :real_ip => context.rack_env["HTTP_X_REAL_IP"],
+        :forwarded_for => context.rack_env["HTTP_X_FORWARDED_FOR"]
+      ).calculate_ip
+    end
+
+    def async_json_processors
+      [
+        Raven::Processor::RemoveCircularReferences,
+        Raven::Processor::UTF8Conversion
+      ].map { |v| v.new(self) }
+    end
+
+    def exception_chain_to_array(exc)
+      if exc.respond_to?(:cause) && exc.cause
+        exceptions = [exc]
+        while exc.cause
+          exc = exc.cause
+          break if exceptions.any? { |e| e.object_id == exc.object_id }
+          exceptions << exc
+        end
+        exceptions.reverse!
+      else
+        [exc]
+      end
+    end
+
+    def list_gem_specs
+      # Older versions of Rubygems don't support iterating over all specs
+      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
+    end
+  end
+end

data/lib/raven/instance.rb

@@ -0,0 +1,221 @@
+module Raven
+  # A copy of Raven's base module class methods, minus some of the integration
+  # and global hooks since it's meant to be used explicitly. Useful for
+  # sending errors to multiple sentry projects in a large application.
+  #
+  # @example
+  #   class Foo
+  #     def initialize
+  #       @other_raven = Raven::Instance.new
+  #       @other_raven.configure do |config|
+  #         config.server = 'http://...'
+  #       end
+  #     end
+  #
+  #     def foo
+  #       # ...
+  #     rescue => e
+  #       @other_raven.capture_exception(e)
+  #     end
+  #   end
+  class Instance
+    # See Raven::Client.
+    attr_writer :client
+
+    # See Raven::Configuration.
+    attr_accessor :configuration
+
+    def initialize(context = nil, config = nil)
+      @context = @explicit_context = context
+      self.configuration = config || Configuration.new
+    end
+
+    def context
+      if @explicit_context
+        @context ||= Context.new
+      else
+        Context.current
+      end
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    # The client object is responsible for delivering formatted data to the
+    # Sentry server.
+    def client
+      @client ||= Client.new(configuration)
+    end
+
+    # Tell the log that the client is good to go
+    def report_status
+      return if configuration.silence_ready
+      if configuration.capture_allowed?
+        logger.info "Raven #{VERSION} ready to catch errors"
+      else
+        logger.info "Raven #{VERSION} configured not to capture errors: #{configuration.error_messages}"
+      end
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Raven.configure do |config|
+    #     config.server = 'http://...'
+    #   end
+    def configure
+      yield(configuration) if block_given?
+
+      self.client = Client.new(configuration)
+      report_status
+      client
+    end
+
+    # Send an event to the configured Sentry server
+    #
+    # @example
+    #   evt = Raven::Event.new(:message => "An error")
+    #   Raven.send_event(evt)
+    def send_event(event)
+      client.send_event(event)
+    end
+
+    # Capture and process any exceptions from the given block.
+    #
+    # @example
+    #   Raven.capture do
+    #     MyApp.run
+    #   end
+    def capture(options = {})
+      if block_given?
+        begin
+          yield
+        rescue Error
+          raise # Don't capture Raven errors
+        rescue Exception => e
+          capture_type(e, options)
+          raise
+        end
+      else
+        install_at_exit_hook(options)
+      end
+    end
+
+    def capture_type(obj, options = {})
+      unless configuration.capture_allowed?(obj)
+        logger.debug("#{obj} excluded from capture: #{configuration.error_messages}")
+        return false
+      end
+
+      message_or_exc = obj.is_a?(String) ? "message" : "exception"
+      options[:configuration] = configuration
+      options[:context] = context
+      if (evt = Event.send("from_" + message_or_exc, obj, options))
+        yield evt if block_given?
+        if configuration.async?
+          begin
+            # We have to convert to a JSON-like hash, because background job
+            # processors (esp ActiveJob) may not like weird types in the event hash
+            configuration.async.call(evt.to_json_compatible)
+          rescue => ex
+            logger.error("async event sending failed: #{ex.message}")
+            send_event(evt)
+          end
+        else
+          send_event(evt)
+        end
+        Thread.current["sentry_#{object_id}_last_event_id".to_sym] = evt.id
+        evt
+      end
+    end
+
+    alias capture_message capture_type
+    alias capture_exception capture_type
+
+    def last_event_id
+      Thread.current["sentry_#{object_id}_last_event_id".to_sym]
+    end
+
+    # Provides extra context to the exception prior to it being handled by
+    # Raven. An exception can have multiple annotations, which are merged
+    # together.
+    #
+    # The options (annotation) is treated the same as the ``options``
+    # parameter to ``capture_exception`` or ``Event.from_exception``, and
+    # can contain the same ``:user``, ``:tags``, etc. options as these
+    # methods.
+    #
+    # These will be merged with the ``options`` parameter to
+    # ``Event.from_exception`` at the top of execution.
+    #
+    # @example
+    #   begin
+    #     raise "Hello"
+    #   rescue => exc
+    #     Raven.annotate_exception(exc, :user => { 'id' => 1,
+    #                              'email' => 'foo@example.com' })
+    #   end
+    def annotate_exception(exc, options = {})
+      notes = (exc.instance_variable_defined?(:@__raven_context) && exc.instance_variable_get(:@__raven_context)) || {}
+      Raven::Utils::DeepMergeHash.deep_merge!(notes, options)
+      exc.instance_variable_set(:@__raven_context, notes)
+      exc
+    end
+
+    # Bind user context. Merges with existing context (if any).
+    #
+    # It is recommending that you send at least the ``id`` and ``email``
+    # values. All other values are arbitrary.
+    #
+    # @example
+    #   Raven.user_context('id' => 1, 'email' => 'foo@example.com')
+    def user_context(options = nil)
+      context.user = options || {}
+    end
+
+    # Bind tags context. Merges with existing context (if any).
+    #
+    # Tags are key / value pairs which generally represent things like
+    # application version, environment, role, and server names.
+    #
+    # @example
+    #   Raven.tags_context('my_custom_tag' => 'tag_value')
+    def tags_context(options = nil)
+      context.tags.merge!(options || {})
+    end
+
+    # Bind extra context. Merges with existing context (if any).
+    #
+    # Extra context shows up as Additional Data within Sentry, and is
+    # completely arbitrary.
+    #
+    # @example
+    #   Raven.extra_context('my_custom_data' => 'value')
+    def extra_context(options = nil)
+      context.extra.merge!(options || {})
+    end
+
+    def rack_context(env)
+      env = nil if env.empty?
+
+      context.rack_env = env
+    end
+
+    def breadcrumbs
+      BreadcrumbBuffer.current
+    end
+
+    private
+
+    def install_at_exit_hook(options)
+      at_exit do
+        exception = $ERROR_INFO
+        if exception
+          logger.debug "Caught a post-mortem exception: #{exception.inspect}"
+          capture_type(exception, options)
+        end
+      end
+    end
+  end
+end