sentry-ruby 0.3.0 → 4.2.0

data/lib/sentry/transaction_event.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Sentry
-  class TransactionEvent < Event
-    ATTRIBUTES = %i(
-      event_id level timestamp start_timestamp
-      release environment server_name modules
-      user tags contexts extra
-      transaction platform sdk type
-    )
-
-    attr_accessor(*ATTRIBUTES)
-    attr_accessor :spans
-
-    def start_timestamp=(time)
-      @start_timestamp = time.is_a?(Time) ? time.to_f : time
-    end
-
-    def type
-      "transaction"
-    end
-
-    def to_hash
-      data = super
-      data[:spans] = @spans.map(&:to_hash) if @spans
-      data
-    end
-  end
-end

data/lib/sentry/transport/configuration.rb

@@ -1,21 +0,0 @@
-module Sentry
-  class Transport
-    class Configuration
-      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder, :transport_class
-
-      def initialize
-        @ssl_verification = true
-        @open_timeout = 1
-        @timeout = 2
-      end
-
-      def transport_class=(klass)
-        unless klass.is_a?(Class)
-          raise Sentry::Error.new("config.transport.transport_class must a class. got: #{klass.class}")
-        end
-
-        @transport_class = klass
-      end
-    end
-  end
-end

data/lib/sentry/transport/dummy_transport.rb

@@ -1,14 +0,0 @@
-module Sentry
-  class DummyTransport < Transport
-    attr_accessor :events
-
-    def initialize(*)
-      super
-      @events = []
-    end
-
-    def send_event(event)
-      @events << event
-    end
-  end
-end

data/lib/sentry/transport/http_transport.rb

@@ -1,65 +0,0 @@
-require 'faraday'
-
-module Sentry
-  class HTTPTransport < Transport
-    attr_reader :conn, :adapter
-
-    def initialize(*args)
-      super
-      @adapter = @transport_configuration.http_adapter || Faraday.default_adapter
-      @conn = set_conn
-      @endpoint = @dsn.envelope_endpoint
-    end
-
-    def send_data(data, options = {})
-      unless configuration.sending_allowed?
-        logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
-      end
-
-      conn.post @endpoint do |req|
-        req.headers['Content-Type'] = options[:content_type]
-        req.headers['X-Sentry-Auth'] = generate_auth_header
-        req.body = data
-      end
-    rescue Faraday::Error => e
-      error_info = e.message
-
-      if e.response
-        error_info += "\nbody: #{e.response[:body]}"
-        error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}" if e.response[:headers]['x-sentry-error']
-      end
-
-      raise Sentry::Error, error_info
-    end
-
-    private
-
-    def set_conn
-      server = @dsn.server
-
-      configuration.logger.debug(LOGGER_PROGNAME) { "Sentry HTTP Transport connecting to #{server}" }
-
-      Faraday.new(server, :ssl => ssl_configuration, :proxy => @transport_configuration.proxy) do |builder|
-        @transport_configuration.faraday_builder&.call(builder)
-        builder.response :raise_error
-        builder.options.merge! faraday_opts
-        builder.headers[:user_agent] = "sentry-ruby/#{Sentry::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] = @transport_configuration.public_send(opt) if @transport_configuration.public_send(opt)
-      end
-    end
-
-    def ssl_configuration
-      (@transport_configuration.ssl || {}).merge(
-        :verify => @transport_configuration.ssl_verification,
-        :ca_file => @transport_configuration.ssl_ca_file
-      )
-    end
-  end
-end

data/lib/sentry/transport/state.rb

@@ -1,40 +0,0 @@
-module Sentry
-  class Transport
-    class State
-      def initialize
-        reset
-      end
-
-      def should_try?
-        return true if @status == :online
-
-        interval = @retry_after || [@retry_number, 6].min**2
-        return true if Sentry.utc_now - @last_check >= interval
-
-        false
-      end
-
-      def failure(retry_after = nil)
-        @status = :error
-        @retry_number += 1
-        @last_check = Sentry.utc_now
-        @retry_after = retry_after
-      end
-
-      def success
-        reset
-      end
-
-      def reset
-        @status = :online
-        @retry_number = 0
-        @last_check = nil
-        @retry_after = nil
-      end
-
-      def failed?
-        @status == :error
-      end
-    end
-  end
-end

data/lib/sentry/transport.rb

@@ -1,97 +0,0 @@
-require "json"
-require "base64"
-require "sentry/transport/state"
-
-module Sentry
-  class Transport
-    PROTOCOL_VERSION = '5'
-    USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
-    CONTENT_TYPE = 'application/json'
-
-    attr_accessor :configuration, :state
-
-    def initialize(configuration)
-      @configuration = configuration
-      @transport_configuration = configuration.transport
-      @dsn = configuration.dsn
-      @state = State.new
-    end
-
-    def send_data(data, options = {})
-      raise NotImplementedError
-    end
-
-    def send_event(event)
-      content_type, encoded_data = prepare_encoded_event(event)
-
-      return nil unless encoded_data
-
-      send_data(encoded_data, content_type: content_type)
-
-      state.success
-      event
-    rescue => e
-      failed_for_exception(e, event)
-      nil
-    end
-
-    def generate_auth_header
-      now = Sentry.utc_now.to_i
-      fields = {
-        'sentry_version' => PROTOCOL_VERSION,
-        'sentry_client' => USER_AGENT,
-        'sentry_timestamp' => now,
-        'sentry_key' => @dsn.public_key
-      }
-      fields['sentry_secret'] = @dsn.secret_key if @dsn.secret_key
-      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
-    end
-
-    def encode(event_hash)
-      event_id = event_hash[:event_id] || event_hash['event_id']
-      event_type = event_hash[:type] || event_hash['type']
-
-      envelope = <<~ENVELOPE
-        {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{Sentry.utc_now.iso8601}"}
-        {"type":"#{event_type}","content_type":"application/json"}
-        #{JSON.generate(event_hash)}
-      ENVELOPE
-
-      [CONTENT_TYPE, envelope]
-    end
-
-    private
-
-    def prepare_encoded_event(event)
-      # Convert to hash
-      event_hash = event.to_hash
-
-      unless @state.should_try?
-        failed_for_previous_failure(event_hash)
-        return
-      end
-
-      event_id = event_hash[:event_id] || event_hash['event_id']
-      configuration.logger.info(LOGGER_PROGNAME) { "Sending event #{event_id} to Sentry" }
-      encode(event_hash)
-    end
-
-    def failed_for_exception(e, event)
-      @state.failure
-      configuration.logger.warn(LOGGER_PROGNAME) { "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}" }
-      log_not_sending(event)
-    end
-
-    def failed_for_previous_failure(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Not sending event due to previous failure(s)." }
-      log_not_sending(event)
-    end
-
-    def log_not_sending(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event. Unreported Event: #{Event.get_log_message(event.to_hash)}" }
-    end
-  end
-end
-
-require "sentry/transport/dummy_transport"
-require "sentry/transport/http_transport"

data/lib/sentry/utils/exception_cause_chain.rb

@@ -1,20 +0,0 @@
-module Sentry
-  module Utils
-    module ExceptionCauseChain
-      def self.exception_to_array(exception)
-        if exception.respond_to?(:cause) && exception.cause
-          exceptions = [exception]
-          while exception.cause
-            exception = exception.cause
-            break if exceptions.any? { |e| e.object_id == exception.object_id }
-
-            exceptions << exception
-          end
-          exceptions
-        else
-          [exception]
-        end
-      end
-    end
-  end
-end

data/lib/sentry/utils/real_ip.rb

@@ -1,70 +0,0 @@
-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 Sentry
-  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_reader :ip
-
-      def initialize(
-        remote_addr: nil,
-        client_ip: nil,
-        real_ip: nil,
-        forwarded_for: nil
-      )
-        @remote_addr = remote_addr
-        @client_ip = client_ip
-        @real_ip = real_ip
-        @forwarded_for = forwarded_for
-      end
-
-      def calculate_ip
-        # CGI environment variable set by Rack
-        remote_addr = ips_from(@remote_addr).last
-
-        # Could be a CSV list and/or repeated headers that were concatenated.
-        client_ips    = ips_from(@client_ip)
-        real_ips      = ips_from(@real_ip)
-        forwarded_ips = ips_from(@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
-        @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/sentry/utils/request_id.rb

@@ -1,16 +0,0 @@
-module Sentry
-  module Utils
-    module RequestId
-      REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
-
-      # Request ID based on ActionDispatch::RequestId
-      def self.read_from(env_hash)
-        REQUEST_ID_HEADERS.each do |key|
-          request_id = env_hash[key]
-          return request_id if request_id
-        end
-        nil
-      end
-    end
-  end
-end

data/lib/sentry/version.rb

@@ -1,3 +0,0 @@
-module Sentry
-  VERSION = "0.3.0"
-end

data/lib/sentry-ruby.rb

@@ -1,123 +0,0 @@
-require "forwardable"
-
-require "sentry/version"
-require "sentry/core_ext/object/deep_dup"
-require "sentry/configuration"
-require "sentry/logger"
-require "sentry/event"
-require "sentry/transaction_event"
-require "sentry/span"
-require "sentry/transaction"
-require "sentry/hub"
-require "sentry/rack"
-
-module Sentry
-  class Error < StandardError
-  end
-
-  META = { "name" => "sentry.ruby", "version" => Sentry::VERSION }.freeze
-
-  LOGGER_PROGNAME = "sentry".freeze
-
-  THREAD_LOCAL = :sentry_hub
-
-  def self.sdk_meta
-    META
-  end
-
-  def self.utc_now
-    Time.now.utc
-  end
-
-  class << self
-    extend Forwardable
-
-    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
-
-    def init(&block)
-      config = Configuration.new
-      yield(config)
-      client = Client.new(config)
-      scope = Scope.new
-      hub = Hub.new(client, scope)
-      Thread.current[THREAD_LOCAL] = hub
-      @main_hub = hub
-    end
-
-    def get_main_hub
-      @main_hub
-    end
-
-    def logger
-      configuration.logger
-    end
-
-    def add_breadcrumb(breadcrumb, &block)
-      get_current_scope.breadcrumbs.record(breadcrumb, &block)
-    end
-
-    def configuration
-      get_current_client.configuration
-    end
-
-    def get_current_client
-      get_current_hub.current_client
-    end
-
-    def get_current_hub
-      # we need to assign a hub to the current thread if it doesn't have one yet
-      #
-      # ideally, we should do this proactively whenever a new thread is created
-      # but it's impossible for the SDK to keep track every new thread
-      # so we need to use this rather passive way to make sure the app doesn't crash
-      Thread.current[THREAD_LOCAL] || clone_hub_to_current_thread
-    end
-
-    def clone_hub_to_current_thread
-      Thread.current[THREAD_LOCAL] = get_main_hub.clone
-    end
-
-    def get_current_scope
-      get_current_hub.current_scope
-    end
-
-    def with_scope(&block)
-      get_current_hub.with_scope(&block)
-    end
-
-    def configure_scope(&block)
-      get_current_hub.configure_scope(&block)
-    end
-
-    def send_event(event)
-      get_current_client.send_event(event)
-    end
-
-    def capture_event(event)
-      get_current_hub.capture_event(event)
-    end
-
-    def capture_exception(exception, **options, &block)
-      get_current_hub.capture_exception(exception, **options, &block)
-    end
-
-    def capture_message(message, **options, &block)
-      get_current_hub.capture_message(message, **options, &block)
-    end
-
-    def start_transaction(**options)
-      get_current_hub.start_transaction(**options)
-    end
-
-    def last_event_id
-      get_current_hub.last_event_id
-    end
-
-    def sys_command(command)
-      result = `#{command} 2>&1` rescue nil
-      return if result.nil? || result.empty? || ($CHILD_STATUS && $CHILD_STATUS.exitstatus != 0)
-
-      result.strip
-    end
-  end
-end

data/sentry-ruby.gemspec

@@ -1,26 +0,0 @@
-require_relative "lib/sentry/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "sentry-ruby"
-  spec.version       = Sentry::VERSION
-  spec.authors = ["Sentry Team"]
-  spec.description = spec.summary = "A gem that provides a client interface for the Sentry error logger"
-  spec.email = "accounts@sentry.io"
-  spec.license = 'Apache-2.0'
-  spec.homepage = "https://github.com/getsentry/raven-ruby"
-
-  spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = '>= 2.4'
-  spec.extra_rdoc_files = ["README.md", "LICENSE.txt"]
-  spec.files = `git ls-files | grep -Ev '^(spec|benchmarks|examples)'`.split("\n")
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
-
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "faraday", ">= 1.0"
-end