sentry-ruby-core 5.0.1 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 848bd1089194abb9be8a48b6c1c4c218dfba27a3555d8ae79a5ffe7d52a05569
-  data.tar.gz: c52711ba4c4275d35cc4ed54a0dc0936422a63e199de91c08e3e6964fb80d6d6
+  metadata.gz: bfc28e6f57d57de669447d555889196617f72ce09624b343cd284375021f60f5
+  data.tar.gz: 5a6af91521df30a18ac1d021b2e59cd9e871653f1325cf6d65346e6c1dc91d7e
 SHA512:
-  metadata.gz: fb55681acc83a4c970fbf8dd7c6715fbef7b6d26ad0a4ca674bc463de13881887d33dd8673772e60e25c2c66b6cb1f111a6c23936b1683d74384296924bb2b33
-  data.tar.gz: 598c1571d00ca441b3a351dfe12c56967d3dae8e4f05b4a8f21b3e8fe16d0c94558e8dec5d211ff72aced12d5b433fb0f7f5f1b6ed522206d15847087dafd959
+  metadata.gz: fbe80e4c07f972d3babbf8c26c31cd97da84e91d77e86628a6931f35d7e66c83fb48461838d1a3e402361ee78dd9a3b6dfe849833f08a4573328d0eb4b5e66e1
+  data.tar.gz: 0f081f57f89207ece5279bd77fa89d311c3d516231421ccf60f4b9c232065a606d80eacc53ab460f12e087aa7b2fadfc4cdd4636863cb58261cc4e58a605ad2c

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

@@ -3,24 +3,47 @@
 module Sentry
   # @api private
   class Envelope
-    def initialize(headers)
+    class Item
+      attr_accessor :headers, :payload
+
+      def initialize(headers, payload)
+        @headers = headers
+        @payload = payload
+      end
+
+      def type
+        @headers[:type] || 'event'
+      end
+
+      def to_s
+        <<~ITEM
+          #{JSON.generate(@headers)}
+          #{JSON.generate(@payload)}
+        ITEM
+      end
+    end
+
+    attr_accessor :headers, :items
+
+    def initialize(headers = {})
       @headers = headers
       @items = []
     end
 
     def add_item(headers, payload)
-      @items << [headers, payload]
+      @items << Item.new(headers, payload)
     end
 
     def to_s
-      payload = @items.map do |item_headers, item_payload|
-        <<~ENVELOPE
-          #{JSON.generate(item_headers)}
-          #{JSON.generate(item_payload)}
-        ENVELOPE
-      end.join("\n")
-
-      "#{JSON.generate(@headers)}\n#{payload}"
+      [JSON.generate(@headers), *@items.map(&:to_s)].join("\n")
+    end
+
+    def item_types
+      @items.map(&:type)
+    end
+
+    def event_id
+      @headers[:event_id]
     end
   end
 end

data/lib/sentry/hub.rb

@@ -94,6 +94,8 @@ module Sentry
     def capture_exception(exception, **options, &block)
       check_argument_type!(exception, ::Exception)
 
+      return if Sentry.exception_captured?(exception)
+
       return unless current_client
 
       options[:hint] ||= {}
@@ -102,7 +104,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_SIGNATURE, 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/scope.rb

@@ -173,7 +173,7 @@ module Sentry
     def set_contexts(contexts_hash)
       check_argument_type!(contexts_hash, Hash)
       @contexts.merge!(contexts_hash) do |key, old, new|
-        new.merge(old)
+        old.merge(new)
       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/http_transport.rb

@@ -129,17 +129,14 @@ module Sentry
     def conn
       server = URI(@dsn.server)
 
-      use_ssl = server.scheme == "https"
-      port = use_ssl ? 443 : 80
-
       connection =
         if proxy = @transport_configuration.proxy
-          ::Net::HTTP.new(server.hostname, port, proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
+          ::Net::HTTP.new(server.hostname, server.port, proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
         else
-          ::Net::HTTP.new(server.hostname, port, nil)
+          ::Net::HTTP.new(server.hostname, server.port, nil)
         end
 
-      connection.use_ssl = use_ssl
+      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

data/lib/sentry/transport.rb

@@ -46,23 +46,19 @@ module Sentry
     end
 
     def send_event(event)
-      event_hash = event.to_hash
-      item_type = get_item_type(event_hash)
+      envelope = envelope_from_event(event)
+      send_envelope(envelope)
 
-      if is_rate_limited?(item_type)
-        log_info("Envelope [#{item_type}] not sent: rate limiting")
-        record_lost_event(:ratelimit_backoff, item_type)
-
-        return
-      end
-
-      encoded_data = encode(event)
+      event
+    end
 
-      return nil unless encoded_data
+    def send_envelope(envelope)
+      reject_rate_limited_items(envelope)
 
-      send_data(encoded_data)
+      return if envelope.items.empty?
 
-      event
+      log_info("[Transport] Sending envelope with items [#{envelope.item_types.join(', ')}] #{envelope.event_id} to Sentry")
+      send_data(envelope.to_s)
     end
 
     def is_rate_limited?(item_type)
@@ -106,7 +102,7 @@ module Sentry
       'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
     end
 
-    def encode(event)
+    def envelope_from_event(event)
       # Convert to hash
       event_payload = event.to_hash
       event_id = event_payload[:event_id] || event_payload["event_id"]
@@ -129,9 +125,8 @@ module Sentry
       client_report_headers, client_report_payload = fetch_pending_client_report
       envelope.add_item(client_report_headers, client_report_payload) if client_report_headers
 
-      log_info("Sending envelope [#{item_type}] #{event_id} to Sentry")
 
-      envelope.to_s
+      envelope
     end
 
     def record_lost_event(reason, item_type)
@@ -173,6 +168,19 @@ module Sentry
 
       [item_header, item_payload]
     end
+
+    def reject_rate_limited_items(envelope)
+      envelope.items.reject! do |item|
+        if is_rate_limited?(item.type)
+          log_info("[Transport] Envelope item [#{item.type}] not sent: rate limiting")
+          record_lost_event(:ratelimit_backoff, item.type)
+
+          true
+        else
+          false
+        end
+      end
+    end
   end
 end
 

data/lib/sentry/version.rb

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

data/lib/sentry-ruby.rb

@@ -31,6 +31,8 @@ end
 module Sentry
   META = { "name" => "sentry.ruby", "version" => Sentry::VERSION }.freeze
 
+  CAPTURED_SIGNATURE = :@__sentry_captured
+
   LOGGER_PROGNAME = "sentry".freeze
 
   SENTRY_TRACE_HEADER_NAME = "sentry-trace".freeze
@@ -111,9 +113,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 +145,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 +229,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 +250,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 +281,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 +306,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 +315,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,30 +324,41 @@ 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
 
+    # Checks if the exception object has been captured by the SDK.
+    #
+    # @return [Boolean]
+    def exception_captured?(exc)
+      return false unless initialized?
+      !!exc.instance_variable_get(CAPTURED_SIGNATURE)
+    end
 
     ##### Helpers #####
 
@@ -344,3 +389,4 @@ end
 
 # patches
 require "sentry/net/http"
+require "sentry/redis"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.1.1
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-23 00:00:00.000000000 Z
+date: 2022-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -73,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