sentry-ruby 5.26.0 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb03eb536d1060c3a097a1ff3726ae71c8ffbd0012580d75c491665e054ac7c1
-  data.tar.gz: 65df577369b281f3e1d1d9335e78786a800947c2014b35608d88c863458f24ca
+  metadata.gz: ea228d904661a633e6bdfd3eb0ea4dc6ac129a0fed8f4a0e378e9a6e84de30e0
+  data.tar.gz: 71c6db91301a24a1b05afa798a249de12b31a5d68c45d16f138f73c0999b3183
 SHA512:
-  metadata.gz: b4e398e02a8fe619afc8982760c290a168785c4557dca30767fbeb039032d7907135e84d0598a5ac90b7b1cfb8413ceda83ebe4647702ba5c10c613ff0543574
-  data.tar.gz: 285a3e0f650a41bcb6cc4539f48c7efcb9bc3442f31c76f301089c4672e6d9c790f407dd9d53db4e216df4eacd9be019b5bc46e453437fa1614aa48555541c9a
+  metadata.gz: 07adab1cfe625b662c7cc89867225f40f07a36b0b73b70c916969ad5bac6ec1516bda791b767398e0b48246e5f23e31601d954cec9f724a79d33980e45d6e4d5
+  data.tar.gz: 5072c6873787d7e070050df7aeeb3e9040ca3add4c04f1c4e21c63d12fb241ee6615eced7f71fac5edeee4381d60272069bdc38ce967033ead0e2e76894b2573

data/Gemfile

@@ -3,15 +3,16 @@
 source "https://rubygems.org"
 git_source(:github) { |name| "https://github.com/#{name}.git" }
 
-eval_gemfile "../Gemfile"
+eval_gemfile "../Gemfile.dev"
 
 gem "sentry-ruby", path: "./"
 
+ruby_version = Gem::Version.new(RUBY_VERSION)
+
 rack_version = ENV["RACK_VERSION"]
 rack_version = "3.0.0" if rack_version.nil?
-gem "rack", "~> #{Gem::Version.new(rack_version)}" unless rack_version == "0"
 
-gem "ostruct" if RUBY_VERSION >= "3.4"
+gem "rack", "~> #{Gem::Version.new(rack_version)}" unless rack_version == "0"
 
 redis_rb_version = ENV.fetch("REDIS_RB_VERSION", "5.0")
 gem "redis", "~> #{redis_rb_version}"
@@ -22,7 +23,7 @@ gem "timecop"
 gem "stackprof" unless RUBY_PLATFORM == "java"
 gem "vernier", platforms: :ruby if RUBY_VERSION >= "3.2.1"
 
-gem "graphql", ">= 2.2.6" if RUBY_VERSION.to_f >= 2.7
+gem "graphql", ">= 2.2.6"
 
 gem "benchmark-ips"
 gem "benchmark_driver"
@@ -34,3 +35,24 @@ gem "webrick"
 gem "faraday"
 gem "excon"
 gem "webmock"
+
+group :sequel do
+  gem "sequel"
+
+  sqlite_version = if ruby_version >= Gem::Version.new("3.2")
+    "2.1.0"
+  elsif ruby_version >= Gem::Version.new("3.0")
+    "1.4.0"
+  else
+    "1.3.0"
+  end
+
+  platform :ruby do
+    gem "sqlite3", "~> #{sqlite_version}"
+  end
+
+  platform :jruby do
+    gem "activerecord-jdbcmysql-adapter"
+    gem "jdbc-sqlite3"
+  end
+end

data/README.md

@@ -105,9 +105,9 @@ To learn more about sampling transactions, please visit the [official documentat
 
 * [![Ruby docs](https://img.shields.io/badge/documentation-sentry.io-green.svg?label=ruby%20docs)](https://docs.sentry.io/platforms/ruby/)
 * [![Forum](https://img.shields.io/badge/forum-sentry-green.svg)](https://forum.sentry.io/c/sdks)
-* [![Discord Chat](https://img.shields.io/discord/621778831602221064?logo=discord&logoColor=ffffff&color=7389D8)](https://discord.gg/PXa5Apfe7K)
+* [![Discord Chat](https://img.shields.io/discord/621778831602221064?logo=discord&logoColor=ffffff&color=7389D8)](https://discord.gg/sentry)
 * [![Stack Overflow](https://img.shields.io/badge/stack%20overflow-sentry-green.svg)](https://stackoverflow.com/questions/tagged/sentry)
-* [![Twitter Follow](https://img.shields.io/twitter/follow/getsentry?label=getsentry&style=social)](https://twitter.com/intent/follow?screen_name=getsentry)
+* [![X Follow](https://img.shields.io/twitter/follow/sentry?label=sentry&style=social)](https://x.com/intent/follow?screen_name=sentry)
 
 ## Contributing to the SDK
 

data/lib/sentry/background_worker.rb

@@ -23,10 +23,7 @@ module Sentry
       @shutdown_callback = nil
 
       @executor =
-        if configuration.async
-          log_debug("config.async is set, BackgroundWorker is disabled")
-          Concurrent::ImmediateExecutor.new
-        elsif @number_of_threads == 0
+        if @number_of_threads == 0
           log_debug("config.background_worker_threads is set to 0, all events will be sent synchronously")
           Concurrent::ImmediateExecutor.new
         else

data/lib/sentry/backtrace/line.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Backtrace
+    # Handles backtrace parsing line by line
+    class Line
+      RB_EXTENSION = ".rb"
+      # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
+      RUBY_INPUT_FORMAT = /
+        ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
+        (\d+)
+        (?: :in\s('|`)(?:([\w:]+)\#)?([^']+)')?$
+      /x
+
+      # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
+      JAVA_INPUT_FORMAT = /^([\w$.]+)\.([\w$]+)\(([\w$.]+):(\d+)\)$/
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # The module name (JRuby)
+      attr_reader :module_name
+
+      attr_reader :in_app_pattern
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line, in_app_pattern = nil)
+        ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
+
+        if ruby_match
+          _, file, number, _, module_name, method = ruby_match.to_a
+          file.sub!(/\.class$/, RB_EXTENSION)
+          module_name = module_name
+        else
+          java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
+          _, module_name, method, file, number = java_match.to_a
+        end
+        new(file, number, method, module_name, in_app_pattern)
+      end
+
+      # Creates a Line from a Thread::Backtrace::Location object
+      # This is more efficient than converting to string and parsing with regex
+      # @param [Thread::Backtrace::Location] location The location object
+      # @param [Regexp, nil] in_app_pattern Optional pattern to determine if the line is in-app
+      # @return [Line] The backtrace line
+      def self.from_source_location(location, in_app_pattern = nil)
+        file = location.absolute_path
+        number = location.lineno
+        method = location.base_label
+
+        label = location.label
+        index = label.index("#") || label.index(".")
+        module_name = label[0, index] if index
+
+        new(file, number, method, module_name, in_app_pattern)
+      end
+
+      def initialize(file, number, method, module_name, in_app_pattern)
+        @file = file
+        @module_name = module_name
+        @number = number.to_i
+        @method = method
+        @in_app_pattern = in_app_pattern
+      end
+
+      def in_app
+        return false unless in_app_pattern
+
+        if file =~ in_app_pattern
+          true
+        else
+          false
+        end
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{self}>"
+      end
+    end
+  end
+end

data/lib/sentry/backtrace.rb

@@ -1,86 +1,12 @@
 # frozen_string_literal: true
 
 require "rubygems"
+require "concurrent/map"
+require "sentry/backtrace/line"
 
 module Sentry
   # @api private
   class Backtrace
-    # Handles backtrace parsing line by line
-    class Line
-      RB_EXTENSION = ".rb"
-      # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
-      RUBY_INPUT_FORMAT = /
-        ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
-        (\d+)
-        (?: :in\s('|`)(?:([\w:]+)\#)?([^']+)')?$
-      /x
-
-      # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
-      JAVA_INPUT_FORMAT = /^([\w$.]+)\.([\w$]+)\(([\w$.]+):(\d+)\)$/
-
-      # The file portion of the line (such as app/models/user.rb)
-      attr_reader :file
-
-      # The line number portion of the line
-      attr_reader :number
-
-      # The method of the line (such as index)
-      attr_reader :method
-
-      # The module name (JRuby)
-      attr_reader :module_name
-
-      attr_reader :in_app_pattern
-
-      # Parses a single line of a given backtrace
-      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
-      # @return [Line] The parsed backtrace line
-      def self.parse(unparsed_line, in_app_pattern = nil)
-        ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
-
-        if ruby_match
-          _, file, number, _, module_name, method = ruby_match.to_a
-          file.sub!(/\.class$/, RB_EXTENSION)
-          module_name = module_name
-        else
-          java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
-          _, module_name, method, file, number = java_match.to_a
-        end
-        new(file, number, method, module_name, in_app_pattern)
-      end
-
-      def initialize(file, number, method, module_name, in_app_pattern)
-        @file = file
-        @module_name = module_name
-        @number = number.to_i
-        @method = method
-        @in_app_pattern = in_app_pattern
-      end
-
-      def in_app
-        return false unless in_app_pattern
-
-        if file =~ in_app_pattern
-          true
-        else
-          false
-        end
-      end
-
-      # Reconstructs the line in a readable fashion
-      def to_s
-        "#{file}:#{number}:in `#{method}'"
-      end
-
-      def ==(other)
-        to_s == other.to_s
-      end
-
-      def inspect
-        "<Line:#{self}>"
-      end
-    end
-
     # holder for an Array of Backtrace::Line instances
     attr_reader :lines
 
@@ -100,6 +26,48 @@ module Sentry
       new(lines)
     end
 
+    # Thread.each_caller_location is an API added in Ruby 3.2 that doesn't always collect
+    # the entire stack like Kernel#caller or #caller_locations do.
+    #
+    # @see https://github.com/rails/rails/pull/49095 for more context.
+    if Thread.respond_to?(:each_caller_location)
+      def self.source_location(&backtrace_cleaner)
+        Thread.each_caller_location do |location|
+          frame_key = [location.absolute_path, location.lineno]
+          cached_value = line_cache[frame_key]
+
+          next if cached_value == :skip
+
+          if cached_value
+            return cached_value
+          else
+            if cleaned_frame = backtrace_cleaner.(location)
+              line = Line.from_source_location(location)
+              line_cache[frame_key] = line
+
+              return line
+            else
+              line_cache[frame_key] = :skip
+
+              next
+            end
+          end
+        end
+      end
+
+      def self.line_cache
+        @line_cache ||= Concurrent::Map.new
+      end
+    else
+      # Since Sentry is mostly used in production, we don't want to fallback
+      # to the slower implementation and adds potentially big overhead to the
+      # application.
+      def self.source_location(*)
+        nil
+      end
+    end
+
+
     def initialize(lines)
       @lines = lines
     end

data/lib/sentry/breadcrumb.rb

@@ -34,7 +34,7 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       {
         category: @category,
         data: serialized_data,

data/lib/sentry/breadcrumb_buffer.rb

@@ -48,9 +48,9 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       {
-        values: members.map(&:to_hash)
+        values: members.map(&:to_h)
       }
     end
 

data/lib/sentry/check_in_event.rb

@@ -48,13 +48,13 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = super
       data[:check_in_id] = check_in_id
       data[:monitor_slug] = monitor_slug
       data[:status] = status
       data[:duration] = duration if duration
-      data[:monitor_config] = monitor_config.to_hash if monitor_config
+      data[:monitor_config] = monitor_config.to_h if monitor_config
       data
     end
   end

data/lib/sentry/client.rb

@@ -3,7 +3,10 @@
 require "sentry/transport"
 require "sentry/log_event"
 require "sentry/log_event_buffer"
+require "sentry/metric_event"
+require "sentry/metric_event_buffer"
 require "sentry/utils/uuid"
+require "sentry/utils/encoding_helper"
 
 module Sentry
   class Client
@@ -20,6 +23,9 @@ module Sentry
     # @!visibility private
     attr_reader :log_event_buffer
 
+    # @!visibility private
+    attr_reader :metric_event_buffer
+
     # @!macro configuration
     attr_reader :configuration
 
@@ -43,7 +49,11 @@ module Sentry
       @spotlight_transport = SpotlightTransport.new(configuration) if configuration.spotlight
 
       if configuration.enable_logs
-        @log_event_buffer = LogEventBuffer.new(configuration, self).start
+        @log_event_buffer = LogEventBuffer.new(configuration, self)
+      end
+
+      if configuration.enable_metrics
+        @metric_event_buffer = MetricEventBuffer.new(configuration, self)
       end
     end
 
@@ -60,8 +70,7 @@ module Sentry
         return
       end
 
-      event_type = event.is_a?(Event) ? event.type : event["type"]
-      data_category = Envelope::Item.data_category(event_type)
+      data_category = Envelope::Item.data_category(event.type)
 
       is_transaction = event.is_a?(TransactionEvent)
       spans_before = is_transaction ? event.spans.size : 0
@@ -78,9 +87,7 @@ module Sentry
         transport.record_lost_event(:event_processor, "span", num: spans_delta) if spans_delta > 0
       end
 
-      if async_block = configuration.async
-        dispatch_async_event(async_block, event, hint)
-      elsif configuration.background_worker_threads != 0 && hint.fetch(:background, true)
+      if configuration.background_worker_threads != 0 && hint.fetch(:background, true)
         unless dispatch_background_event(event, hint)
           transport.record_lost_event(:queue_overflow, data_category)
           transport.record_lost_event(:queue_overflow, "span", num: spans_before + 1) if is_transaction
@@ -100,7 +107,17 @@ module Sentry
     # @return [LogEvent]
     def buffer_log_event(event, scope)
       return unless event.is_a?(LogEvent)
-      @log_event_buffer.add_event(scope.apply_to_event(event))
+      @log_event_buffer.add_item(scope.apply_to_telemetry(event))
+      event
+    end
+
+    # Buffer a metric event to be sent later with other metrics in a single envelope
+    # @param event [MetricEvent] the metric event to be buffered
+    # @return [MetricEvent]
+    def buffer_metric_event(event, scope)
+      return unless event.is_a?(MetricEvent)
+      event = scope.apply_to_telemetry(event)
+      @metric_event_buffer.add_item(event)
       event
     end
 
@@ -117,6 +134,7 @@ module Sentry
       transport.flush if configuration.sending_to_dsn_allowed?
       spotlight_transport.flush if spotlight_transport
       @log_event_buffer&.flush
+      @metric_event_buffer&.flush
     end
 
     # Initializes an Event object with the given exception. Returns `nil` if the exception's class is excluded from reporting.
@@ -195,9 +213,19 @@ module Sentry
     def event_from_log(message, level:, **options)
       return unless configuration.sending_allowed?
 
-      attributes = options.reject { |k, _| k == :level || k == :severity }
+      attributes = options.reject { |k, _| k == :level || k == :severity || k == :origin }
+      origin = options[:origin]
+      body = Utils::EncodingHelper.safe_utf_8_string(message)
+
+      sanitized_attributes = attributes.transform_values do |value|
+        if value.is_a?(String)
+          Utils::EncodingHelper.safe_utf_8_string(value)
+        else
+          value
+        end
+      end
 
-      LogEvent.new(level: level, body: message, attributes: attributes)
+      LogEvent.new(level: level, body: body, attributes: sanitized_attributes, origin: origin)
     end
 
     # Initializes an Event object with the given Transaction object.
@@ -209,22 +237,13 @@ module Sentry
 
     # @!macro send_event
     def send_event(event, hint = nil)
-      event_type = event.is_a?(Event) ? event.type : event["type"]
-      data_category = Envelope::Item.data_category(event_type)
+      data_category = Envelope::Item.data_category(event.type)
       spans_before = event.is_a?(TransactionEvent) ? event.spans.size : 0
 
-      if event_type != TransactionEvent::TYPE && configuration.before_send
+      if event.is_a?(ErrorEvent) && configuration.before_send
         event = configuration.before_send.call(event, hint)
 
-        case event
-        when ErrorEvent, CheckInEvent
-          # do nothing
-        when Hash
-          log_debug(<<~MSG)
-            Returning a Hash from before_send is deprecated and will be removed in the next major version.
-            Please return a Sentry::ErrorEvent object instead.
-          MSG
-        else
+        if !event.is_a?(ErrorEvent)
           # Avoid serializing the event object in this case because we aren't sure what it is and what it contains
           log_debug(<<~MSG)
             Discarded event because before_send didn't return a Sentry::ErrorEvent object but an instance of #{event.class}
@@ -234,21 +253,10 @@ module Sentry
         end
       end
 
-      if event_type == TransactionEvent::TYPE && configuration.before_send_transaction
+      if event.is_a?(TransactionEvent) && configuration.before_send_transaction
         event = configuration.before_send_transaction.call(event, hint)
 
-        if event.is_a?(TransactionEvent) || event.is_a?(Hash)
-          spans_after = event.is_a?(TransactionEvent) ? event.spans.size : 0
-          spans_delta = spans_before - spans_after
-          transport.record_lost_event(:before_send, "span", num: spans_delta) if spans_delta > 0
-
-          if event.is_a?(Hash)
-            log_debug(<<~MSG)
-              Returning a Hash from before_send_transaction is deprecated and will be removed in the next major version.
-              Please return a Sentry::TransactionEvent object instead.
-            MSG
-          end
-        else
+        if !event.is_a?(TransactionEvent)
           # Avoid serializing the event object in this case because we aren't sure what it is and what it contains
           log_debug(<<~MSG)
             Discarded event because before_send_transaction didn't return a Sentry::TransactionEvent object but an instance of #{event.class}
@@ -257,6 +265,23 @@ module Sentry
           transport.record_lost_event(:before_send, "span", num: spans_before + 1)
           return
         end
+
+        spans_after = event.is_a?(TransactionEvent) ? event.spans.size : 0
+        spans_delta = spans_before - spans_after
+        transport.record_lost_event(:before_send, "span", num: spans_delta) if spans_delta > 0
+      end
+
+      if event.is_a?(CheckInEvent) && configuration.before_send_check_in
+        event = configuration.before_send_check_in.call(event, hint)
+
+        if !event.is_a?(CheckInEvent)
+          # Avoid serializing the event object in this case because we aren't sure what it is and what it contains
+          log_debug(<<~MSG)
+            Discarded event because before_send_check_in didn't return a Sentry::CheckInEvent object but an instance of #{event.class}
+          MSG
+          transport.record_lost_event(:before_send, data_category)
+          return
+        end
       end
 
       transport.send_event(event) if configuration.sending_to_dsn_allowed?
@@ -270,53 +295,6 @@ module Sentry
       raise
     end
 
-    # Send an envelope with batched logs
-    # @param log_events [Array<LogEvent>] the log events to be sent
-    # @api private
-    # @return [void]
-    def send_logs(log_events)
-      envelope = Envelope.new(
-        event_id: Sentry::Utils.uuid,
-        sent_at: Sentry.utc_now.iso8601,
-        dsn: configuration.dsn,
-        sdk: Sentry.sdk_meta
-      )
-
-      discarded_count = 0
-      envelope_items = []
-
-      if configuration.before_send_log
-        log_events.each do |log_event|
-          processed_log_event = configuration.before_send_log.call(log_event)
-
-          if processed_log_event
-            envelope_items << processed_log_event.to_hash
-          else
-            discarded_count += 1
-          end
-        end
-
-        envelope_items
-      else
-        envelope_items = log_events.map(&:to_hash)
-      end
-
-      envelope.add_item(
-        {
-          type: "log",
-          item_count: envelope_items.size,
-          content_type: "application/vnd.sentry.items.log+json"
-        },
-        { items: envelope_items }
-      )
-
-      send_envelope(envelope)
-
-      unless discarded_count.zero?
-        transport.record_lost_event(:before_send, "log_item", num: discarded_count)
-      end
-    end
-
     # Send an envelope directly to Sentry.
     # @param envelope [Envelope] the envelope to be sent.
     # @return [void]
@@ -333,38 +311,6 @@ module Sentry
       raise
     end
 
-    # @deprecated use Sentry.get_traceparent instead.
-    #
-    # Generates a Sentry trace for distribted tracing from the given Span.
-    # Returns `nil` if `config.propagate_traces` is `false`.
-    # @param span [Span] the span to generate trace from.
-    # @return [String, nil]
-    def generate_sentry_trace(span)
-      return unless configuration.propagate_traces
-
-      trace = span.to_sentry_trace
-      log_debug("[Tracing] Adding #{SENTRY_TRACE_HEADER_NAME} header to outgoing request: #{trace}")
-      trace
-    end
-
-    # @deprecated Use Sentry.get_baggage instead.
-    #
-    # Generates a W3C Baggage header for distributed tracing from the given Span.
-    # Returns `nil` if `config.propagate_traces` is `false`.
-    # @param span [Span] the span to generate trace from.
-    # @return [String, nil]
-    def generate_baggage(span)
-      return unless configuration.propagate_traces
-
-      baggage = span.to_baggage
-
-      if baggage && !baggage.empty?
-        log_debug("[Tracing] Adding #{BAGGAGE_HEADER_NAME} header to outgoing request: #{baggage}")
-      end
-
-      baggage
-    end
-
     private
 
     def dispatch_background_event(event, hint)
@@ -372,28 +318,5 @@ module Sentry
         send_event(event, hint)
       end
     end
-
-    def dispatch_async_event(async_block, event, hint)
-      # We have to convert to a JSON-like hash, because background job
-      # processors (esp ActiveJob) may not like weird types in the event hash
-
-      event_hash =
-        begin
-          event.to_json_compatible
-        rescue => e
-          log_error("Converting #{event.type} (#{event.event_id}) to JSON compatible hash failed", e, debug: configuration.debug)
-          return
-        end
-
-      if async_block.arity == 2
-        hint = JSON.parse(JSON.generate(hint))
-        async_block.call(event_hash, hint)
-      else
-        async_block.call(event_hash)
-      end
-    rescue => e
-      log_error("Async #{event_hash["type"]} sending failed", e, debug: configuration.debug)
-      send_event(event, hint)
-    end
   end
 end