sentry-ruby 5.28.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a048bcf517a994eb2577cc8f9630e7771f0dbe9a80cff9a93e1d4d68186db49
-  data.tar.gz: 97d7489043a301a9fdfed0d9ca31d38156c5082a0a2e43e83592d86e9eba939d
+  metadata.gz: b0a6e7b2113d1332eaaf78dc5b8a4989b0a1395796a43fb1f7225cc8115f0ac5
+  data.tar.gz: 64aaefd79ec8d357586ec99cea6f21d749f21a5fc80226b9a554f5f6a3f25870
 SHA512:
-  metadata.gz: 17466b57a83b0292b367b43dcf7c22128ae93822ab7481f3afb3459c52842c917c57d3b2274a3e377fcfd089ab10efa1e12bdd7401a991018387fb026e5fe014
-  data.tar.gz: cbea0779676929f05597e84da1e4cd7cc25fa0a6d383c8d08e6e26112e9bbe90403d14fdebaa8164a18d5db894ec286d22e5611da217a7bd5efb9279119ace33
+  metadata.gz: 4db52a4de3aada20c59eec1f949d8577fa2acf6a1772ca450fca97ddbbbf6676654ee60a585c82af020d54bd24b5ccc593dcad86e54e44bfcaafc6d385e4fac5
+  data.tar.gz: d3489ef60748f864cb4ad59f5f823ad5ca6a3ff6aee54e6c859a140af4947bffca91c37ae1dca5ee9d46d18b2b4e33f1df69085d328168eed96842443fd00719

data/Gemfile

@@ -20,7 +20,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"

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/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

@@ -60,8 +60,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 +77,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
@@ -210,22 +207,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}
@@ -235,21 +223,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}
@@ -258,6 +235,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?
@@ -291,7 +285,7 @@ module Sentry
           processed_log_event = configuration.before_send_log.call(log_event)
 
           if processed_log_event
-            envelope_items << processed_log_event.to_hash
+            envelope_items << processed_log_event.to_h
           else
             discarded_count += 1
           end
@@ -299,7 +293,7 @@ module Sentry
 
         envelope_items
       else
-        envelope_items = log_events.map(&:to_hash)
+        envelope_items = log_events.map(&:to_h)
       end
 
       envelope.add_item(
@@ -334,38 +328,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)
@@ -373,28 +335,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

data/lib/sentry/configuration.rb

@@ -9,7 +9,6 @@ require "sentry/dsn"
 require "sentry/release_detector"
 require "sentry/transport/configuration"
 require "sentry/cron/configuration"
-require "sentry/metrics/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
 require "sentry/logger"
@@ -31,13 +30,6 @@ module Sentry
     # @return [Regexp, nil]
     attr_accessor :app_dirs_pattern
 
-    # Provide an object that responds to `call` to send events asynchronously.
-    # E.g.: lambda { |event| Thread.new { Sentry.send_event(event) } }
-    #
-    # @deprecated It will be removed in the next major release. Please read https://github.com/getsentry/sentry-ruby/issues/1522 for more information
-    # @return [Proc, nil]
-    attr_reader :async
-
     # to send events in a non-blocking way, sentry-ruby has its own background worker
     # by default, the worker holds a thread pool that has [the number of processors] threads
     # but you can configure it with this configuration option
@@ -75,11 +67,10 @@ module Sentry
     # @return [Proc]
     attr_reader :before_breadcrumb
 
-    # Optional Proc, called before sending an event to the server
+    # Optional Proc, called before sending an error event to the server
     # @example
     #   config.before_send = lambda do |event, hint|
     #     # skip ZeroDivisionError exceptions
-    #     # note: hint[:exception] would be a String if you use async callback
     #     if hint[:exception].is_a?(ZeroDivisionError)
     #       nil
     #     else
@@ -89,7 +80,7 @@ module Sentry
     # @return [Proc]
     attr_reader :before_send
 
-    # Optional Proc, called before sending an event to the server
+    # Optional Proc, called before sending a transaction event to the server
     # @example
     #   config.before_send_transaction = lambda do |event, hint|
     #     # skip unimportant transactions or strip sensitive data
@@ -102,6 +93,18 @@ module Sentry
     # @return [Proc]
     attr_reader :before_send_transaction
 
+    # Optional Proc, called before sending a check-in event to the server
+    # @example
+    #   config.before_send_check_in = lambda do |event, hint|
+    #     if event.monitor_slug == "unimportant_job"
+    #       nil
+    #     else
+    #       event
+    #     end
+    #   end
+    # @return [Proc]
+    attr_reader :before_send_check_in
+
     # Optional Proc, called before sending an event to the server
     # @example
     #   config.before_send_log = lambda do |log|
@@ -118,7 +121,6 @@ module Sentry
     #
     # And if you also use sentry-rails:
     # - :active_support_logger
-    # - :monotonic_active_support_logger
     #
     # @return [Array<Symbol>]
     attr_reader :breadcrumbs_logger
@@ -145,7 +147,7 @@ module Sentry
     attr_reader :dsn
 
     # Whitelist of enabled_environments that will send notifications to Sentry. Array of Strings.
-    # @return [Array<String>]
+    # @return [Array<String>, nil]
     attr_accessor :enabled_environments
 
     # Logger 'progname's to exclude from breadcrumbs
@@ -174,18 +176,6 @@ module Sentry
     # @return [Boolean, String]
     attr_accessor :spotlight
 
-    # @deprecated Use {#include_local_variables} instead.
-    alias_method :capture_exception_frame_locals, :include_local_variables
-
-    # @deprecated Use {#include_local_variables=} instead.
-    def capture_exception_frame_locals=(value)
-      log_warn <<~MSG
-        `capture_exception_frame_locals` is now deprecated in favor of `include_local_variables`.
-      MSG
-
-      self.include_local_variables = value
-    end
-
     # You may provide your own LineCache for matching paths with source files.
     # This may be useful if you need to get source code from places other than the disk.
     # @see LineCache
@@ -202,18 +192,6 @@ module Sentry
     # @return [String, nil]
     attr_accessor :sdk_debug_transport_log_file
 
-    # @deprecated Use {#sdk_logger=} instead.
-    def logger=(logger)
-      warn "[sentry] `config.logger=` is deprecated. Please use `config.sdk_logger=` instead."
-      self.sdk_logger = logger
-    end
-
-    # @deprecated Use {#sdk_logger} instead.
-    def logger
-      warn "[sentry] `config.logger` is deprecated. Please use `config.sdk_logger` instead."
-      self.sdk_logger
-    end
-
     # Project directory root for in_app detection. Could be Rails root, etc.
     # Set automatically for Rails.
     # @return [String]
@@ -273,10 +251,6 @@ module Sentry
     # @return [Cron::Configuration]
     attr_reader :cron
 
-    # Metrics related configuration.
-    # @return [Metrics::Configuration]
-    attr_reader :metrics
-
     # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
     # @return [Float, nil]
     attr_reader :traces_sample_rate
@@ -299,12 +273,6 @@ module Sentry
     # @return [StructuredLoggingConfiguration]
     attr_reader :structured_logging
 
-    # Easier way to use performance tracing
-    # If set to true, will set traces_sample_rate to 1.0
-    # @deprecated It will be removed in the next major release.
-    # @return [Boolean, nil]
-    attr_reader :enable_tracing
-
     # Send diagnostic client reports about dropped events, true by default
     # tries to attach to an existing envelope max once every 30s
     # @return [Boolean]
@@ -325,6 +293,18 @@ module Sentry
     # @return [Array<String, Regexp>]
     attr_accessor :trace_propagation_targets
 
+    # Collection of HTTP status codes or ranges of codes to ignore when tracing incoming requests.
+    # If a transaction's http.response.status_code matches one of these values,
+    # the transaction will be dropped and marked as not sampled.
+    # Defaults to TRACE_IGNORE_STATUS_CODES_DEFAULT.
+    #
+    # @example
+    #   # ignore 404 and 502 <= status_code <= 511
+    #   config.trace_ignore_status_codes = [404, (502..511)]
+    #
+    # @return [Array<Integer>, Array<Range>]
+    attr_reader :trace_ignore_status_codes
+
     # The instrumenter to use, :sentry or :otel
     # @return [Symbol]
     attr_reader :instrumenter
@@ -339,6 +319,15 @@ module Sentry
     # @return [Float, nil]
     attr_reader :profiles_sample_rate
 
+    # Interval in microseconds at which to take samples.
+    # The default is 1e6 / 101, or 101Hz.
+    # Note that the 101 is intentional to avoid lockstep sampling.
+    #
+    # @example
+    #   config.profiles_sample_interval = 1e5 / 101
+    # @return [Float]
+    attr_accessor :profiles_sample_interval
+
     # Array of patches to apply.
     # Default is {DEFAULT_PATCHES}
     # @return [Array<Symbol>]
@@ -376,6 +365,8 @@ module Sentry
       SERVER_PORT
     ].freeze
 
+    TRACE_IGNORE_STATUS_CODES_DEFAULT = [(301..303), (305..399), (401..404)]
+
     HEROKU_DYNO_METADATA_MESSAGE = "You are running on Heroku but haven't enabled Dyno Metadata. For Sentry's "\
     "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`"
 
@@ -391,6 +382,9 @@ module Sentry
 
     APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test|spec)/
 
+    # 101 Hz in microseconds
+    DEFAULT_PROFILES_SAMPLE_INTERVAL = 1e6 / 101
+
     class << self
       # Post initialization callbacks are called at the end of initialization process
       # allowing extending the configuration of sentry-ruby by multiple extensions
@@ -473,7 +467,7 @@ module Sentry
       self.context_lines = 3
       self.include_local_variables = false
       self.environment = environment_from_env
-      self.enabled_environments = []
+      self.enabled_environments = nil
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT + PUMA_IGNORE_DEFAULT
       self.inspect_exception_causes_for_exclusion = true
@@ -498,21 +492,22 @@ module Sentry
       self.server_name = server_name_from_env
       self.instrumenter = :sentry
       self.trace_propagation_targets = [PROPAGATION_TARGETS_MATCH_ALL]
+      self.trace_ignore_status_codes = TRACE_IGNORE_STATUS_CODES_DEFAULT
       self.enabled_patches = DEFAULT_PATCHES.dup
 
       self.before_send = nil
       self.before_send_transaction = nil
+      self.before_send_check_in = nil
       self.before_send_log = nil
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
       self.traces_sampler = nil
-      self.enable_tracing = nil
       self.enable_logs = false
 
       self.profiler_class = Sentry::Profiler
+      self.profiles_sample_interval = DEFAULT_PROFILES_SAMPLE_INTERVAL
 
       @transport = Transport::Configuration.new
       @cron = Cron::Configuration.new
-      @metrics = Metrics::Configuration.new(self.sdk_logger)
       @structured_logging = StructuredLoggingConfiguration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
@@ -555,22 +550,6 @@ module Sentry
       @release = value
     end
 
-    def async=(value)
-      check_callable!("async", value)
-
-      log_warn <<~MSG
-
-        sentry-ruby now sends events asynchronously by default with its background worker (supported since 4.1.0).
-        The `config.async` callback has become redundant while continuing to cause issues.
-        (The problems of `async` are detailed in https://github.com/getsentry/sentry-ruby/issues/1522)
-
-        Therefore, we encourage you to remove it and let the background worker take care of async job sending.
-      It's deprecation is planned in the next major release (6.0), which is scheduled around the 3rd quarter of 2022.
-      MSG
-
-      @async = value
-    end
-
     def breadcrumbs_logger=(logger)
       loggers =
         if logger.is_a?(Array)
@@ -596,6 +575,12 @@ module Sentry
       @before_send_transaction = value
     end
 
+    def before_send_check_in=(value)
+      check_callable!("before_send_check_in", value)
+
+      @before_send_check_in = value
+    end
+
     def before_breadcrumb=(value)
       check_callable!("before_breadcrumb", value)
 
@@ -610,15 +595,12 @@ module Sentry
       @instrumenter = INSTRUMENTERS.include?(instrumenter) ? instrumenter : :sentry
     end
 
-    def enable_tracing=(enable_tracing)
-      unless enable_tracing.nil?
-        log_warn <<~MSG
-          `enable_tracing` is now deprecated in favor of `traces_sample_rate = 1.0`.
-        MSG
+    def trace_ignore_status_codes=(codes)
+      unless codes.is_a?(Array) && codes.all? { |code| valid_status_code_entry?(code) }
+        raise ArgumentError, "trace_ignore_status_codes must be an Array of integers or ranges between (100-599) where begin <= end"
       end
 
-      @enable_tracing = enable_tracing
-      @traces_sample_rate ||= 1.0 if enable_tracing
+      @trace_ignore_status_codes = codes
     end
 
     def traces_sample_rate=(traces_sample_rate)
@@ -674,7 +656,7 @@ module Sentry
     end
 
     def enabled_in_current_env?
-      enabled_environments.empty? || enabled_environments.include?(environment)
+      enabled_environments.nil? || enabled_environments.include?(environment)
     end
 
     def valid_sample_rate?(sample_rate)
@@ -685,7 +667,7 @@ module Sentry
     def tracing_enabled?
       valid_sampler = !!((valid_sample_rate?(@traces_sample_rate)) || @traces_sampler)
 
-      (@enable_tracing != false) && valid_sampler && sending_allowed?
+      valid_sampler && sending_allowed?
     end
 
     def profiling_enabled?
@@ -816,6 +798,23 @@ module Sentry
       available_processor_count = Concurrent.available_processor_count if Concurrent.respond_to?(:available_processor_count)
       available_processor_count || Concurrent.processor_count
     end
+
+    def valid_http_status_code?(code)
+      code.is_a?(Integer) && code >= 100 && code <= 599
+    end
+
+    def valid_status_code_entry?(entry)
+      case entry
+      when Integer
+        valid_http_status_code?(entry)
+      when Range
+        valid_http_status_code?(entry.begin) &&
+          valid_http_status_code?(entry.end) &&
+          entry.begin <= entry.end
+      else
+        false
+      end
+    end
   end
 
   class StructuredLoggingConfiguration

data/lib/sentry/cron/monitor_check_ins.rb

@@ -14,12 +14,12 @@ module Sentry
                                                 :in_progress,
                                                 monitor_config: monitor_config)
 
-          start = Metrics::Timing.duration_start
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
           begin
             # need to do this on ruby <= 2.6 sadly
             ret = method(:perform).super_method.arity == 0 ? super() : super
-            duration = Metrics::Timing.duration_end(start)
+            duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
             Sentry.capture_check_in(slug,
                                     :ok,
@@ -29,7 +29,7 @@ module Sentry
 
             ret
           rescue Exception
-            duration = Metrics::Timing.duration_end(start)
+            duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
             Sentry.capture_check_in(slug,
                                     :error,

data/lib/sentry/cron/monitor_config.rb

@@ -40,9 +40,9 @@ module Sentry
         new(MonitorSchedule::Interval.new(num, unit), **options)
       end
 
-      def to_hash
+      def to_h
         {
-          schedule: schedule.to_hash,
+          schedule: schedule.to_h,
           checkin_margin: checkin_margin,
           max_runtime: max_runtime,
           timezone: timezone

data/lib/sentry/cron/monitor_schedule.rb

@@ -12,7 +12,7 @@ module Sentry
           @value = value
         end
 
-        def to_hash
+        def to_h
           { type: :crontab, value: value }
         end
       end
@@ -33,7 +33,7 @@ module Sentry
           @unit = unit
         end
 
-        def to_hash
+        def to_h
           { type: :interval, value: value, unit: unit }
         end
       end

data/lib/sentry/envelope/item.rb

@@ -3,7 +3,7 @@
 module Sentry
   # @api private
   class Envelope::Item
-    STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
+    STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 1000
     MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 1000
 
     SIZE_LIMITS = Hash.new(MAX_SERIALIZED_PAYLOAD_SIZE).update(
@@ -18,7 +18,6 @@ module Sentry
       when "session", "attachment", "transaction", "profile", "span", "log" then type
       when "sessions" then "session"
       when "check_in" then "monitor"
-      when "statsd", "metric_meta" then "metric_bucket"
       when "event" then "error"
       when "client_report" then "internal"
       else "default"

data/lib/sentry/error_event.rb

@@ -10,10 +10,10 @@ module Sentry
     attr_reader :threads
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = super
-      data[:threads] = threads.to_hash if threads
-      data[:exception] = exception.to_hash if exception
+      data[:threads] = threads.to_h if threads
+      data[:exception] = exception.to_h if exception
       data
     end