sentry-ruby-core 4.9.2 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cf9f47960b6d555a19ee4859d686f535b238a0046999039b1bd24958d8a65cf
-  data.tar.gz: 7c99f67a943ed2cd8cc5f2c006aeb8b9dd89664997abacb83133d11ebeca2904
+  metadata.gz: e8b9d0c43497ccc151613d208b6e9a51489586a41cbb7849cbcfcd3e5795765f
+  data.tar.gz: 79e7e9f621b2fe8bfc1c1dc292a16392e499925c13bdc1c31c3f8e05240f42e0
 SHA512:
-  metadata.gz: 4e049ffe7513c8f78274093ff3f4f2ef6e754b442611352525453d9c040fb30391e63fd5e668c83e464e3b3293d003aa4944f00b66741a66176ad913a47949db
-  data.tar.gz: 8f0b9a6cef78cdab2804ffa2a3dd6de029672430ade59d907f6c1d60f6143817445d5c79524e0a1a66e95ffe0c2acba2b0a93af844057b172ec1fbb8b8fc420f
+  metadata.gz: 3def5710a658f0365dbe11292f548aafcaf6d467d04abd5e0973035c5c3243307d49347b829ae0aa93d459c2bf4036813ec2a4589471c8da21d438318144c0aa
+  data.tar.gz: 99eab89037a4e468c7bb257d33aaf85ec8830102aa233a9af4c5091c92d67726f4ffab47b3eeedba07f079b4b3600145458e9283274532b534824acd21236617

data/Gemfile

@@ -9,6 +9,7 @@ gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "rspec-retry"
 gem "webmock"
+gem "fakeredis"
 gem "timecop"
 gem 'simplecov'
 gem "simplecov-cobertura", "~> 1.4"

data/lib/sentry/client.rb

@@ -108,6 +108,7 @@ module Sentry
         event.contexts.merge!(trace: transaction.get_trace_context)
         event.timestamp = transaction.timestamp
         event.start_timestamp = transaction.start_timestamp
+        event.tags = transaction.tags
 
         finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
         event.spans = finished_spans.map(&:to_hash)

data/lib/sentry/configuration.rb

@@ -75,6 +75,7 @@ module Sentry
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
     # - :http_logger
+    # - :redis_logger
     #
     # And if you also use sentry-rails:
     # - :active_support_logger

data/lib/sentry/hub.rb

@@ -102,7 +102,10 @@ module Sentry
 
       return unless event
 
-      capture_event(event, **options, &block)
+      capture_event(event, **options, &block).tap do
+        # mark the exception as captured so we can use this information to avoid duplicated capturing
+        exception.instance_variable_set(:@__sentry_captured, true)
+      end
     end
 
     def capture_message(message, **options, &block)

data/lib/sentry/interfaces/request.rb

@@ -62,7 +62,7 @@ module Sentry
       self.url = request.scheme && request.url.split('?').first
       self.method = request.request_method
 
-      self.headers = filter_and_format_headers(env)
+      self.headers = filter_and_format_headers(env, send_default_pii)
       self.env     = filter_and_format_env(env, rack_env_whitelist)
     end
 
@@ -81,13 +81,14 @@ module Sentry
       e.message
     end
 
-    def filter_and_format_headers(env)
+    def filter_and_format_headers(env, send_default_pii)
       env.each_with_object({}) do |(key, value), memo|
         begin
           key = key.to_s # rack env can contain symbols
           next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
           next if is_server_protocol?(key, value, env["SERVER_PROTOCOL"])
           next if is_skippable_header?(key)
+          next if key == "HTTP_AUTHORIZATION" && !send_default_pii
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
           key = key.sub(/^HTTP_/, "")

data/lib/sentry/net/http.rb

@@ -6,7 +6,8 @@ module Sentry
   # @api private
   module Net
     module HTTP
-      OP_NAME = "net.http"
+      OP_NAME = "http.client"
+      BREADCRUMB_CATEGORY = "net.http"
 
       # To explain how the entire thing works, we need to know how the original Net::HTTP#request works
       # Here's part of its definition. As you can see, it usually calls itself inside a #start block
@@ -53,7 +54,7 @@ module Sentry
 
         crumb = Sentry::Breadcrumb.new(
           level: :info,
-          category: OP_NAME,
+          category: BREADCRUMB_CATEGORY,
           type: :info,
           data: {
             status: res.code.to_i,

data/lib/sentry/redis.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Redis
+    OP_NAME ||= "db.redis.command"
+    LOGGER_NAME ||= :redis_logger
+
+    def initialize(commands, host, port, db)
+      @commands, @host, @port, @db = commands, host, port, db
+    end
+
+    def instrument
+      return yield unless Sentry.initialized?
+
+      record_span do
+        yield.tap do
+          record_breadcrumb
+        end
+      end
+    end
+
+    private
+
+    attr_reader :commands, :host, :port, :db
+
+    def record_span
+      return yield unless (transaction = Sentry.get_current_scope.get_transaction) && transaction.sampled
+
+      sentry_span = transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
+
+      yield.tap do
+        sentry_span.set_description(commands_description)
+        sentry_span.set_data(:server, server_description)
+        sentry_span.set_timestamp(Sentry.utc_now.to_f)
+      end
+    end
+
+    def record_breadcrumb
+      return unless Sentry.configuration.breadcrumbs_logger.include?(LOGGER_NAME)
+
+      Sentry.add_breadcrumb(
+        Sentry::Breadcrumb.new(
+          level: :info,
+          category: OP_NAME,
+          type: :info,
+          data: {
+            commands: parsed_commands,
+            server: server_description
+          }
+        )
+      )
+    end
+
+    def commands_description
+      parsed_commands.map do |statement|
+        statement.values.join(" ").strip
+      end.join(", ")
+    end
+
+    def parsed_commands
+      commands.map do |statement|
+        command, key, *_values = statement
+
+        { command: command.to_s.upcase, key: key }
+      end
+    end
+
+    def server_description
+      "#{host}:#{port}/#{db}"
+    end
+
+    module Client
+      def logging(commands, &block)
+        Sentry::Redis.new(commands, host, port, db).instrument do
+          super
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Redis::Client)
+  Sentry.register_patch do
+    patch = Sentry::Redis::Client
+    Redis::Client.prepend(patch) unless Redis::Client.ancestors.include?(patch)
+  end
+end

data/lib/sentry/transaction.rb

@@ -164,13 +164,12 @@ module Sentry
         @name = UNLABELD_NAME
       end
 
-      unless @sampled || @parent_sampled
+      if @sampled
+        event = hub.current_client.event_from_transaction(self)
+        hub.capture_event(event)
+      else
         hub.current_client.transport.record_lost_event(:sample_rate, 'transaction')
-        return
       end
-
-      event = hub.current_client.event_from_transaction(self)
-      hub.capture_event(event)
     end
 
     protected

data/lib/sentry/transport/configuration.rb

@@ -3,8 +3,7 @@
 module Sentry
   class Transport
     class Configuration
-      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder,
-        :encoding
+      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :encoding
       attr_reader :transport_class
 
       def initialize

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/version.rb

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

data/lib/sentry-ruby.rb

@@ -111,9 +111,17 @@ module Sentry
 
     # @!method configuration
     #   @!macro configuration
+    def configuration
+      return unless initialized?
+      get_current_client.configuration
+    end
+
     # @!method send_event
     #   @!macro send_event
-    def_delegators :get_current_client, :configuration, :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.
@@ -135,13 +143,31 @@ module Sentry
 
     # @!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_delegators :get_current_scope, :set_tags, :set_extras, :set_user, :set_context
+    def set_context(*args)
+      return unless initialized?
+      get_current_scope.set_context(*args)
+    end
 
     ##### Main APIs #####
 
@@ -201,7 +227,8 @@ module Sentry
     #
     # @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.
@@ -221,14 +248,16 @@ module Sentry
     # 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.
@@ -250,7 +279,8 @@ module Sentry
     # @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.
@@ -274,7 +304,8 @@ module Sentry
     # @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.
@@ -282,7 +313,8 @@ module Sentry
     # @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.
@@ -290,28 +322,32 @@ module Sentry
     # @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
 
 
@@ -344,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.9.2
+  version: 5.1.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-18 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
@@ -87,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