sentry-ruby-core 4.8.1 → 5.1.0

data/lib/sentry/transport/http_transport.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'faraday'
-require 'zlib'
+require "net/http"
+require "zlib"
 
 module Sentry
   class HTTPTransport < Transport
@@ -12,14 +12,13 @@ module Sentry
     DEFAULT_DELAY = 60
     RETRY_AFTER_HEADER = "retry-after"
     RATE_LIMIT_HEADER = "x-sentry-rate-limits"
-
-    attr_reader :conn, :adapter
+    USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
 
     def initialize(*args)
       super
-      @adapter = @transport_configuration.http_adapter || Faraday.default_adapter
-      @conn = set_conn
       @endpoint = @dsn.envelope_endpoint
+
+      log_debug("Sentry HTTP Transport will connect to #{@dsn.server}")
     end
 
     def send_data(data)
@@ -30,29 +29,37 @@ module Sentry
         encoding = GZIP_ENCODING
       end
 
-      response = conn.post @endpoint do |req|
-        req.headers['Content-Type'] = CONTENT_TYPE
-        req.headers['Content-Encoding'] = encoding
-        req.headers['X-Sentry-Auth'] = generate_auth_header
-        req.body = data
+      headers = {
+        'Content-Type' => CONTENT_TYPE,
+        'Content-Encoding' => encoding,
+        'X-Sentry-Auth' => generate_auth_header,
+        'User-Agent' => USER_AGENT
+      }
+
+      response = conn.start do |http|
+        request = ::Net::HTTP::Post.new(@endpoint, headers)
+        request.body = data
+        http.request(request)
       end
 
-      if has_rate_limited_header?(response.headers)
-        handle_rate_limited_response(response.headers)
-      end
-    rescue Faraday::Error => e
-      error_info = e.message
+      if response.code.match?(/\A2\d{2}/)
+        if has_rate_limited_header?(response)
+          handle_rate_limited_response(response)
+        end
+      else
+        error_info = "the server responded with status #{response.code}"
 
-      if e.response
-        if e.response[:status] == 429
-          handle_rate_limited_response(e.response[:headers])
+        if response.code == "429"
+          handle_rate_limited_response(response)
         else
-          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']
+          error_info += "\nbody: #{response.body}"
+          error_info += " Error in headers is: #{response['x-sentry-error']}" if response['x-sentry-error']
         end
-      end
 
-      raise Sentry::ExternalError, error_info
+        raise Sentry::ExternalError, error_info
+      end
+    rescue SocketError => e
+      raise Sentry::ExternalError.new(e.message)
     end
 
     private
@@ -119,32 +126,36 @@ module Sentry
       @transport_configuration.encoding == GZIP_ENCODING && data.bytesize >= GZIP_THRESHOLD
     end
 
-    def set_conn
-      server = @dsn.server
+    def conn
+      server = URI(@dsn.server)
 
-      log_debug("Sentry HTTP Transport connecting to #{server}")
+      connection =
+        if proxy = @transport_configuration.proxy
+          ::Net::HTTP.new(server.hostname, server.port, proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
+        else
+          ::Net::HTTP.new(server.hostname, server.port, nil)
+        end
 
-      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
+      connection.use_ssl = server.scheme == "https"
+      connection.read_timeout = @transport_configuration.timeout
+      connection.write_timeout = @transport_configuration.timeout if connection.respond_to?(:write_timeout)
+      connection.open_timeout = @transport_configuration.open_timeout
 
-    # 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)
+      ssl_configuration.each do |key, value|
+        connection.send("#{key}=", value)
       end
+
+      connection
     end
 
     def ssl_configuration
-      {
+      configuration = {
         verify: @transport_configuration.ssl_verification,
         ca_file: @transport_configuration.ssl_ca_file
       }.merge(@transport_configuration.ssl || {})
+
+      configuration[:verify_mode] = configuration.delete(:verify) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      configuration
     end
   end
 end

data/lib/sentry/transport.rb

@@ -23,7 +23,10 @@ module Sentry
 
     include LoggingHelper
 
-    attr_reader :logger, :rate_limits, :discarded_events, :last_client_report_sent
+    attr_reader :rate_limits, :discarded_events, :last_client_report_sent
+
+    # @deprecated Use Sentry.logger to retrieve the current logger instead.
+    attr_reader :logger
 
     def initialize(configuration)
       @logger = configuration.logger

data/lib/sentry/utils/logging_helper.rb

@@ -6,21 +6,21 @@ module Sentry
       message = "#{message}: #{exception.message}"
       message += "\n#{exception.backtrace.join("\n")}" if debug
 
-      logger.error(LOGGER_PROGNAME) do
+      @logger.error(LOGGER_PROGNAME) do
         message
       end
     end
 
     def log_info(message)
-      logger.info(LOGGER_PROGNAME) { message }
+      @logger.info(LOGGER_PROGNAME) { message }
     end
 
     def log_debug(message)
-      logger.debug(LOGGER_PROGNAME) { message }
+      @logger.debug(LOGGER_PROGNAME) { message }
     end
 
     def log_warn(message)
-      logger.warn(LOGGER_PROGNAME) { message }
+      @logger.warn(LOGGER_PROGNAME) { message }
     end
   end
 end

data/lib/sentry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentry
-  VERSION = "4.8.1"
+  VERSION = "5.1.0"
 end

data/lib/sentry-ruby.rb

@@ -18,7 +18,6 @@ require "sentry/transaction"
 require "sentry/hub"
 require "sentry/background_worker"
 
-
 [
   "sentry/rake",
   "sentry/rack",
@@ -39,6 +38,7 @@ module Sentry
   THREAD_LOCAL = :sentry_hub
 
   class << self
+    # @!visibility private
     def exception_locals_tp
       @exception_locals_tp ||= TracePoint.new(:raise) do |tp|
         exception = tp.raised_exception
@@ -55,46 +55,126 @@ module Sentry
       end
     end
 
+    # @!attribute [rw] background_worker
+    #   @return [BackgroundWorker]
     attr_accessor :background_worker
 
     ##### Patch Registration #####
-    #
+
+    # @!visibility private
     def register_patch(&block)
       registered_patches << block
     end
 
+    # @!visibility private
     def apply_patches(config)
       registered_patches.each do |patch|
         patch.call(config)
       end
     end
 
+    # @!visibility private
     def registered_patches
       @registered_patches ||= []
     end
 
     ##### Integrations #####
-    #
+
     # Returns a hash that contains all the integrations that have been registered to the main SDK.
+    #
+    # @return [Hash{String=>Hash}]
     def integrations
       @integrations ||= {}
     end
 
     # Registers the SDK integration with its name and version.
+    #
+    # @param name [String] name of the integration
+    # @param version [String] version of the integration
     def register_integration(name, version)
       meta = { name: "sentry.ruby.#{name}", version: version }.freeze
       integrations[name.to_s] = meta
     end
 
     ##### Method Delegation #####
-    #
+
     extend Forwardable
 
-    def_delegators :get_current_client, :configuration, :send_event
-    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user, :set_context
+    # @!macro [new] configuration
+    #   The Configuration object that's used for configuring the client and its transport.
+    #   @return [Configuration]
+    # @!macro [new] send_event
+    #   Sends the event to Sentry.
+    #   @param event [Event] the event to be sent.
+    #   @param hint [Hash] the hint data that'll be passed to `before_send` callback.
+    #   @return [Event]
+
+    # @!method configuration
+    #   @!macro configuration
+    def configuration
+      return unless initialized?
+      get_current_client.configuration
+    end
+
+    # @!method send_event
+    #   @!macro send_event
+    def send_event(*args)
+      return unless initialized?
+      get_current_client.send_event(*args)
+    end
+
+    # @!macro [new] set_extras
+    #   Updates the scope's extras attribute by merging with the old value.
+    #   @param extras [Hash]
+    #   @return [Hash]
+    # @!macro [new] set_user
+    #   Sets the scope's user attribute.
+    #   @param user [Hash]
+    #   @return [Hash]
+    # @!macro [new] set_context
+    #   Adds a new key-value pair to current contexts.
+    #   @param key [String, Symbol]
+    #   @param value [Object]
+    #   @return [Hash]
+    # @!macro [new] set_tags
+    #   Updates the scope's tags attribute by merging with the old value.
+    #   @param tags [Hash]
+    #   @return [Hash]
+
+    # @!method set_tags
+    #   @!macro set_tags
+    def set_tags(*args)
+      return unless initialized?
+      get_current_scope.set_tags(*args)
+    end
+
+    # @!method set_extras
+    #   @!macro set_extras
+    def set_extras(*args)
+      return unless initialized?
+      get_current_scope.set_extras(*args)
+    end
+
+    # @!method set_user
+    #   @!macro set_user
+    def set_user(*args)
+      return unless initialized?
+      get_current_scope.set_user(*args)
+    end
+
+    # @!method set_context
+    #   @!macro set_context
+    def set_context(*args)
+      return unless initialized?
+      get_current_scope.set_context(*args)
+    end
 
     ##### Main APIs #####
+
+    # Initializes the SDK with given configuration.
     #
+    # @yieldparam config [Configuration]
+    # @return [void]
     def init(&block)
       config = Configuration.new
       yield(config) if block_given?
@@ -116,31 +196,46 @@ module Sentry
       end
     end
 
+    # Returns true if the SDK is initialized.
+    #
+    # @return [Boolean]
+    def initialized?
+      !!get_main_hub
+    end
+
     # Returns an uri for security policy reporting that's generated from the given DSN
     # (To learn more about security policy reporting: https://docs.sentry.io/product/security-policy-reporting/)
     #
     # It returns nil if
+    # - The SDK is not initialized yet.
+    # - The DSN is not provided or is invalid.
     #
-    # 1. The SDK is not initialized yet.
-    # 2. The DSN is not provided or is invalid.
+    # @return [String, nil]
     def csp_report_uri
       return unless initialized?
       configuration.csp_report_uri
     end
 
     # Returns the main thread's active hub.
+    #
+    # @return [Hub]
     def get_main_hub
       @main_hub
     end
 
     # Takes an instance of Sentry::Breadcrumb and stores it to the current active scope.
+    #
+    # @return [Breadcrumb, nil]
     def add_breadcrumb(breadcrumb, **options)
-      get_current_hub&.add_breadcrumb(breadcrumb, **options)
+      return unless initialized?
+      get_current_hub.add_breadcrumb(breadcrumb, **options)
     end
 
     # Returns the current active hub.
     # If the current thread doesn't have an active hub, it will clone the main thread's active hub,
     # stores it in the current thread, and then returns it.
+    #
+    # @return [Hub]
     def get_current_hub
       # we need to assign a hub to the current thread if it doesn't have one yet
       #
@@ -151,85 +246,114 @@ module Sentry
     end
 
     # Returns the current active client.
+    # @return [Client, nil]
     def get_current_client
-      get_current_hub&.current_client
+      return unless initialized?
+      get_current_hub.current_client
     end
 
     # Returns the current active scope.
+    #
+    # @return [Scope, nil]
     def get_current_scope
-      get_current_hub&.current_scope
+      return unless initialized?
+      get_current_hub.current_scope
     end
 
     # Clones the main thread's active hub and stores it to the current thread.
+    #
+    # @return [void]
     def clone_hub_to_current_thread
       Thread.current.thread_variable_set(THREAD_LOCAL, get_main_hub.clone)
     end
 
     # Takes a block and yields the current active scope.
     #
-    # ```ruby
-    # Sentry.configure_scope do |scope|
-    #   scope.set_tags(foo: "bar")
-    # end
+    # @example
+    #   Sentry.configure_scope do |scope|
+    #     scope.set_tags(foo: "bar")
+    #   end
     #
-    # Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
-    # ```
+    #   Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
     #
+    # @yieldparam scope [Scope]
+    # @return [void]
     def configure_scope(&block)
-      get_current_hub&.configure_scope(&block)
+      return unless initialized?
+      get_current_hub.configure_scope(&block)
     end
 
     # Takes a block and yields a temporary scope.
     # The temporary scope will inherit all the attributes from the current active scope and replace it to be the active
-    # scope inside the block. For example:
+    # scope inside the block.
     #
-    # ```ruby
-    # Sentry.configure_scope do |scope|
-    #   scope.set_tags(foo: "bar")
-    # end
+    # @example
+    #   Sentry.configure_scope do |scope|
+    #     scope.set_tags(foo: "bar")
+    #   end
     #
-    # Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
+    #   Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
     #
-    # Sentry.with_scope do |temp_scope|
-    #   temp_scope.set_tags(foo: "baz")
-    #   Sentry.capture_message("test message 2") # this event will have tags { foo: "baz" }
-    # end
+    #   Sentry.with_scope do |temp_scope|
+    #     temp_scope.set_tags(foo: "baz")
+    #     Sentry.capture_message("test message 2") # this event will have tags { foo: "baz" }
+    #   end
     #
-    # Sentry.capture_message("test message 3") # this event will have tags { foo: "bar" }
-    # ```
+    #   Sentry.capture_message("test message 3") # this event will have tags { foo: "bar" }
     #
+    # @yieldparam scope [Scope]
+    # @return [void]
     def with_scope(&block)
-      get_current_hub&.with_scope(&block)
+      return unless initialized?
+      get_current_hub.with_scope(&block)
     end
 
     # Takes an exception and reports it to Sentry via the currently active hub.
+    #
+    # @yieldparam scope [Scope]
+    # @return [Event, nil]
     def capture_exception(exception, **options, &block)
-      get_current_hub&.capture_exception(exception, **options, &block)
+      return unless initialized?
+      get_current_hub.capture_exception(exception, **options, &block)
     end
 
     # Takes a message string and reports it to Sentry via the currently active hub.
+    #
+    # @yieldparam scope [Scope]
+    # @return [Event, nil]
     def capture_message(message, **options, &block)
-      get_current_hub&.capture_message(message, **options, &block)
+      return unless initialized?
+      get_current_hub.capture_message(message, **options, &block)
     end
 
     # Takes an instance of Sentry::Event and dispatches it to the currently active hub.
+    #
+    # @return [Event, nil]
     def capture_event(event)
-      get_current_hub&.capture_event(event)
+      return unless initialized?
+      get_current_hub.capture_event(event)
     end
 
     # Takes or initializes a new Sentry::Transaction and makes a sampling decision for it.
+    #
+    # @return [Transaction, nil]
     def start_transaction(**options)
-      get_current_hub&.start_transaction(**options)
+      return unless initialized?
+      get_current_hub.start_transaction(**options)
     end
 
     # Returns the id of the lastly reported Sentry::Event.
+    #
+    # @return [String, nil]
     def last_event_id
-      get_current_hub&.last_event_id
+      return unless initialized?
+      get_current_hub.last_event_id
     end
 
 
     ##### Helpers #####
-    #
+
+    # @!visibility private
     def sys_command(command)
       result = `#{command} 2>&1` rescue nil
       return if result.nil? || result.empty? || ($CHILD_STATUS && $CHILD_STATUS.exitstatus != 0)
@@ -237,18 +361,17 @@ module Sentry
       result.strip
     end
 
-    def initialized?
-      !!@main_hub
-    end
-
+    # @!visibility private
     def logger
       configuration.logger
     end
 
+    # @!visibility private
     def sdk_meta
       META
     end
 
+    # @!visibility private
     def utc_now
       Time.now.utc
     end
@@ -257,3 +380,4 @@ end
 
 # patches
 require "sentry/net/http"
+require "sentry/redis"

data/sentry-ruby-core.gemspec

@@ -22,6 +22,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "faraday"
   spec.add_dependency "concurrent-ruby"
 end

data/sentry-ruby.gemspec

@@ -18,6 +18,5 @@ Gem::Specification.new do |spec|
   spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
 
   spec.add_dependency "sentry-ruby-core", Sentry::VERSION
-  spec.add_dependency "faraday", ">= 1.0"
   spec.add_dependency "concurrent-ruby", '~> 1.0', '>= 1.0.2'
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 4.8.1
+  version: 5.1.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-22 00:00:00.000000000 Z
+date: 2022-02-10 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -48,6 +34,7 @@ extra_rdoc_files:
 files:
 - ".gitignore"
 - ".rspec"
+- ".yardopts"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -86,6 +73,7 @@ files:
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exceptions.rb
 - lib/sentry/rake.rb
+- lib/sentry/redis.rb
 - lib/sentry/release_detector.rb
 - lib/sentry/scope.rb
 - lib/sentry/span.rb