sentry-ruby 5.18.2 → 5.28.1

data/lib/sentry/log_event.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Sentry
+  # Event type that represents a log entry with its attributes
+  #
+  # @see https://develop.sentry.dev/sdk/telemetry/logs/#log-envelope-item-payload
+  class LogEvent
+    TYPE = "log"
+
+    DEFAULT_PARAMETERS = [].freeze
+    DEFAULT_ATTRIBUTES = {}.freeze
+
+    SERIALIZEABLE_ATTRIBUTES = %i[
+      level
+      body
+      timestamp
+      environment
+      release
+      server_name
+      trace_id
+      attributes
+      contexts
+    ]
+
+    SENTRY_ATTRIBUTES = {
+      "sentry.trace.parent_span_id" => :parent_span_id,
+      "sentry.environment" => :environment,
+      "sentry.release" => :release,
+      "sentry.address" => :server_name,
+      "sentry.sdk.name" => :sdk_name,
+      "sentry.sdk.version" => :sdk_version,
+      "sentry.message.template" => :template,
+      "sentry.origin" => :origin
+    }
+
+    PARAMETER_PREFIX = "sentry.message.parameter"
+
+    USER_ATTRIBUTES = {
+      "user.id" => :user_id,
+      "user.name" => :user_username,
+      "user.email" => :user_email
+    }
+
+    LEVELS = %i[trace debug info warn error fatal].freeze
+
+    attr_accessor :level, :body, :template, :attributes, :user, :origin
+
+    attr_reader :configuration, *(SERIALIZEABLE_ATTRIBUTES - %i[level body attributes])
+
+    SERIALIZERS = %i[
+      attributes
+      body
+      level
+      parent_span_id
+      sdk_name
+      sdk_version
+      template
+      timestamp
+      trace_id
+      user_id
+      user_username
+      user_email
+    ].map { |name| [name, :"serialize_#{name}"] }.to_h
+
+    VALUE_TYPES = Hash.new("string").merge!({
+      TrueClass => "boolean",
+      FalseClass => "boolean",
+      Integer => "integer",
+      Float => "double"
+    }).freeze
+
+    TOKEN_REGEXP = /%\{(\w+)\}/
+
+    def initialize(configuration: Sentry.configuration, **options)
+      @configuration = configuration
+      @type = TYPE
+      @server_name = configuration.server_name
+      @environment = configuration.environment
+      @release = configuration.release
+      @timestamp = Sentry.utc_now
+      @level = options.fetch(:level)
+      @body = options[:body]
+      @template = @body if is_template?
+      @attributes = options[:attributes] || DEFAULT_ATTRIBUTES
+      @user = options[:user] || {}
+      @origin = options[:origin]
+      @contexts = {}
+    end
+
+    def to_hash
+      SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |name, memo|
+        memo[name] = serialize(name)
+      end
+    end
+
+    private
+
+    def serialize(name)
+      serializer = SERIALIZERS[name]
+
+      if serializer
+        __send__(serializer)
+      else
+        public_send(name)
+      end
+    end
+
+    def serialize_level
+      level.to_s
+    end
+
+    def serialize_sdk_name
+      Sentry.sdk_meta["name"]
+    end
+
+    def serialize_sdk_version
+      Sentry.sdk_meta["version"]
+    end
+
+    def serialize_timestamp
+      timestamp.to_f
+    end
+
+    def serialize_trace_id
+      contexts.dig(:trace, :trace_id)
+    end
+
+    def serialize_parent_span_id
+      contexts.dig(:trace, :parent_span_id)
+    end
+
+    def serialize_body
+      if parameters.empty?
+        body
+      elsif parameters.is_a?(Hash)
+        body % parameters
+      else
+        sprintf(body, *parameters)
+      end
+    end
+
+    def serialize_user_id
+      user[:id]
+    end
+
+    def serialize_user_username
+      user[:username]
+    end
+
+    def serialize_user_email
+      user[:email]
+    end
+
+    def serialize_template
+      template if has_parameters?
+    end
+
+    def serialize_attributes
+      hash = {}
+
+      attributes.each do |key, value|
+        hash[key] = attribute_hash(value)
+      end
+
+      SENTRY_ATTRIBUTES.each do |key, name|
+        if (value = serialize(name))
+          hash[key] = attribute_hash(value)
+        end
+      end
+
+      USER_ATTRIBUTES.each do |key, name|
+        if (value = serialize(name))
+          hash[key] = value
+        end
+      end
+
+      hash
+    end
+
+    def attribute_hash(value)
+      { value: value, type: value_type(value) }
+    end
+
+    def value_type(value)
+      VALUE_TYPES[value.class]
+    end
+
+    def parameters
+      @parameters ||= begin
+        return DEFAULT_PARAMETERS unless template
+
+        parameters = template_tokens.empty? ?
+          attributes.fetch(:parameters, DEFAULT_PARAMETERS) : attributes.slice(*template_tokens)
+
+        if parameters.is_a?(Hash)
+          parameters.each do |key, value|
+            attributes["#{PARAMETER_PREFIX}.#{key}"] = value
+          end
+        else
+          parameters.each_with_index do |param, index|
+            attributes["#{PARAMETER_PREFIX}.#{index}"] = param
+          end
+        end
+      end
+    end
+
+    def template_tokens
+      @template_tokens ||= body.scan(TOKEN_REGEXP).flatten.map(&:to_sym)
+    end
+
+    def is_template?
+      body.include?("%s") || TOKEN_REGEXP.match?(body)
+    end
+
+    def has_parameters?
+      attributes.keys.any? { |key| key.start_with?(PARAMETER_PREFIX) }
+    end
+  end
+end

data/lib/sentry/log_event_buffer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "sentry/threaded_periodic_worker"
+
+module Sentry
+  # LogEventBuffer buffers log events and sends them to Sentry in a single envelope.
+  #
+  # This is used internally by the `Sentry::Client`.
+  #
+  # @!visibility private
+  class LogEventBuffer < ThreadedPeriodicWorker
+    FLUSH_INTERVAL = 5 # seconds
+    DEFAULT_MAX_EVENTS = 100
+
+    # @!visibility private
+    attr_reader :pending_events
+
+    def initialize(configuration, client)
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
+
+      @client = client
+      @pending_events = []
+      @max_events = configuration.max_log_events || DEFAULT_MAX_EVENTS
+      @mutex = Mutex.new
+
+      log_debug("[Logging] Initialized buffer with max_events=#{@max_events}, flush_interval=#{FLUSH_INTERVAL}s")
+    end
+
+    def start
+      ensure_thread
+      self
+    end
+
+    def flush
+      @mutex.synchronize do
+        return if empty?
+
+        log_debug("[LogEventBuffer] flushing #{size} log events")
+
+        send_events
+      end
+
+      log_debug("[LogEventBuffer] flushed #{size} log events")
+
+      self
+    end
+    alias_method :run, :flush
+
+    def add_event(event)
+      raise ArgumentError, "expected a LogEvent, got #{event.class}" unless event.is_a?(LogEvent)
+
+      @mutex.synchronize do
+        @pending_events << event
+        send_events if size >= @max_events
+      end
+
+      self
+    end
+
+    def empty?
+      @pending_events.empty?
+    end
+
+    def size
+      @pending_events.size
+    end
+
+    private
+
+    def send_events
+      @client.send_logs(@pending_events)
+      @pending_events.clear
+    end
+  end
+end

data/lib/sentry/logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module Sentry
   class Logger < ::Logger

data/lib/sentry/metrics/aggregator.rb

@@ -34,15 +34,15 @@ module Sentry
       attr_reader :client, :thread, :buckets, :flush_shift, :code_locations
 
       def initialize(configuration, client)
-        super(configuration.logger, FLUSH_INTERVAL)
+        super(configuration.sdk_logger, FLUSH_INTERVAL)
         @client = client
         @before_emit = configuration.metrics.before_emit
         @enable_code_locations = configuration.metrics.enable_code_locations
         @stacktrace_builder = configuration.stacktrace_builder
 
         @default_tags = {}
-        @default_tags['release'] = configuration.release if configuration.release
-        @default_tags['environment'] = configuration.environment if configuration.environment
+        @default_tags["release"] = configuration.release if configuration.release
+        @default_tags["environment"] = configuration.environment if configuration.environment
 
         @mutex = Mutex.new
 
@@ -59,7 +59,7 @@ module Sentry
       def add(type,
               key,
               value,
-              unit: 'none',
+              unit: "none",
               tags: {},
               timestamp: nil,
               stacklevel: nil)
@@ -98,7 +98,7 @@ module Sentry
         unless flushable_buckets.empty?
           payload = serialize_buckets(flushable_buckets)
           envelope.add_item(
-            { type: 'statsd', length: payload.bytesize },
+            { type: "statsd", length: payload.bytesize },
             payload
           )
         end
@@ -107,7 +107,7 @@ module Sentry
           code_locations.each do |timestamp, locations|
             payload = serialize_locations(timestamp, locations)
             envelope.add_item(
-              { type: 'metric_meta', content_type: 'application/json' },
+              { type: "metric_meta", content_type: "application/json" },
               payload
             )
           end
@@ -161,8 +161,8 @@ module Sentry
         buckets.map do |timestamp, timestamp_buckets|
           timestamp_buckets.map do |metric_key, metric|
             type, key, unit, tags = metric_key
-            values = metric.serialize.join(':')
-            sanitized_tags = tags.map { |k, v| "#{sanitize_tag_key(k)}:#{sanitize_tag_value(v)}" }.join(',')
+            values = metric.serialize.join(":")
+            sanitized_tags = tags.map { |k, v| "#{sanitize_tag_key(k)}:#{sanitize_tag_value(v)}" }.join(",")
 
             "#{sanitize_key(key)}@#{sanitize_unit(unit)}:#{values}|#{type}|\##{sanitized_tags}|T#{timestamp}"
           end
@@ -175,22 +175,22 @@ module Sentry
           mri = "#{type}:#{sanitize_key(key)}@#{sanitize_unit(unit)}"
 
           # note this needs to be an array but it really doesn't serve a purpose right now
-          [mri, [location.merge(type: 'location')]]
+          [mri, [location.merge(type: "location")]]
         end.to_h
 
         { timestamp: timestamp, mapping: mapping }
       end
 
       def sanitize_key(key)
-        key.gsub(KEY_SANITIZATION_REGEX, '_')
+        key.gsub(KEY_SANITIZATION_REGEX, "_")
       end
 
       def sanitize_unit(unit)
-        unit.gsub(UNIT_SANITIZATION_REGEX, '')
+        unit.gsub(UNIT_SANITIZATION_REGEX, "")
       end
 
       def sanitize_tag_key(key)
-        key.gsub(TAG_KEY_SANITIZATION_REGEX, '')
+        key.gsub(TAG_KEY_SANITIZATION_REGEX, "")
       end
 
       def sanitize_tag_value(value)
@@ -209,7 +209,7 @@ module Sentry
         updated_tags = @default_tags.merge(tags)
 
         transaction_name = get_transaction_name
-        updated_tags['transaction'] = transaction_name if transaction_name
+        updated_tags["transaction"] = transaction_name if transaction_name
 
         updated_tags
       end

data/lib/sentry/metrics/configuration.rb

@@ -4,12 +4,13 @@ module Sentry
   module Metrics
     class Configuration
       include ArgumentCheckingHelper
+      include LoggingHelper
 
       # Enable metrics usage.
       # Starts a new {Sentry::Metrics::Aggregator} instance to aggregate metrics
       # and a thread to aggregate flush every 5 seconds.
       # @return [Boolean]
-      attr_accessor :enabled
+      attr_reader :enabled
 
       # Enable code location reporting.
       # Will be sent once per day.
@@ -32,11 +33,20 @@ module Sentry
       # @return [Proc, nil]
       attr_reader :before_emit
 
-      def initialize
+      def initialize(sdk_logger)
+        @sdk_logger = sdk_logger
         @enabled = false
         @enable_code_locations = true
       end
 
+      def enabled=(value)
+        log_warn <<~MSG
+          `config.metrics` is now deprecated and will be removed in the next major.
+        MSG
+
+        @enabled = value
+      end
+
       def before_emit=(value)
         check_callable!("metrics.before_emit", value)
 

data/lib/sentry/metrics/set_metric.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'zlib'
+require "set"
+require "zlib"
 
 module Sentry
   module Metrics

data/lib/sentry/metrics/timing.rb

@@ -37,6 +37,14 @@ module Sentry
         def week
           Sentry.utc_now.to_i / (3600.0 * 24.0 * 7.0)
         end
+
+        def duration_start
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        def duration_end(start)
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        end
       end
     end
   end

data/lib/sentry/metrics.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'sentry/metrics/metric'
-require 'sentry/metrics/counter_metric'
-require 'sentry/metrics/distribution_metric'
-require 'sentry/metrics/gauge_metric'
-require 'sentry/metrics/set_metric'
-require 'sentry/metrics/timing'
-require 'sentry/metrics/aggregator'
+require "sentry/metrics/metric"
+require "sentry/metrics/counter_metric"
+require "sentry/metrics/distribution_metric"
+require "sentry/metrics/gauge_metric"
+require "sentry/metrics/set_metric"
+require "sentry/metrics/timing"
+require "sentry/metrics/aggregator"
 
 module Sentry
   module Metrics
@@ -14,32 +14,38 @@ module Sentry
     INFORMATION_UNITS = %w[bit byte kilobyte kibibyte megabyte mebibyte gigabyte gibibyte terabyte tebibyte petabyte pebibyte exabyte exbibyte]
     FRACTIONAL_UNITS = %w[ratio percent]
 
-    OP_NAME = 'metric.timing'
-    SPAN_ORIGIN = 'auto.metric.timing'
+    OP_NAME = "metric.timing"
+    SPAN_ORIGIN = "auto.metric.timing"
 
     class << self
-      def increment(key, value = 1.0, unit: 'none', tags: {}, timestamp: nil)
+      def increment(key, value = 1.0, unit: "none", tags: {}, timestamp: nil)
+        log_deprecation
         Sentry.metrics_aggregator&.add(:c, key, value, unit: unit, tags: tags, timestamp: timestamp)
       end
 
-      def distribution(key, value, unit: 'none', tags: {}, timestamp: nil)
+      def distribution(key, value, unit: "none", tags: {}, timestamp: nil)
+        log_deprecation
         Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
       end
 
-      def set(key, value, unit: 'none', tags: {}, timestamp: nil)
+      def set(key, value, unit: "none", tags: {}, timestamp: nil)
+        log_deprecation
         Sentry.metrics_aggregator&.add(:s, key, value, unit: unit, tags: tags, timestamp: timestamp)
       end
 
-      def gauge(key, value, unit: 'none', tags: {}, timestamp: nil)
+      def gauge(key, value, unit: "none", tags: {}, timestamp: nil)
+        log_deprecation
         Sentry.metrics_aggregator&.add(:g, key, value, unit: unit, tags: tags, timestamp: timestamp)
       end
 
-      def timing(key, unit: 'second', tags: {}, timestamp: nil, &block)
+      def timing(key, unit: "second", tags: {}, timestamp: nil, &block)
+        log_deprecation
+
         return unless block_given?
         return yield unless DURATION_UNITS.include?(unit)
 
         result, value = Sentry.with_child_span(op: OP_NAME, description: key, origin: SPAN_ORIGIN) do |span|
-          tags.each { |k, v| span.set_tag(k, v.is_a?(Array) ? v.join(', ') : v.to_s) } if span
+          tags.each { |k, v| span.set_tag(k, v.is_a?(Array) ? v.join(", ") : v.to_s) } if span
 
           start = Timing.send(unit.to_sym)
           result = yield
@@ -51,6 +57,12 @@ module Sentry
         Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
         result
       end
+
+      def log_deprecation
+        Sentry.sdk_logger.warn(LOGGER_PROGNAME) do
+          "`Sentry::Metrics` is now deprecated and will be removed in the next major."
+        end
+      end
     end
   end
 end

data/lib/sentry/net/http.rb

@@ -2,14 +2,18 @@
 
 require "net/http"
 require "resolv"
+require "sentry/utils/http_tracing"
 
 module Sentry
   # @api private
   module Net
     module HTTP
+      include Utils::HttpTracing
+
       OP_NAME = "http.client"
       SPAN_ORIGIN = "auto.http.net_http"
       BREADCRUMB_CATEGORY = "net.http"
+      URI_PARSER = URI.const_defined?("RFC2396_PARSER") ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
 
       # 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
@@ -21,8 +25,7 @@ module Sentry
       #       req['connection'] ||= 'close'
       #       return request(req, body, &block) # <- request will be called for the second time from the first call
       #     }
-      #   end
-      #   # .....
+      #   end # .....
       # end
       # ```
       #
@@ -34,44 +37,26 @@ module Sentry
         Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |sentry_span|
           request_info = extract_request_info(req)
 
-          if propagate_trace?(request_info[:url], Sentry.configuration)
+          if propagate_trace?(request_info[:url])
             set_propagation_headers(req)
           end
 
-          super.tap do |res|
-            record_sentry_breadcrumb(request_info, res)
+          res = super
+          response_status = res.code.to_i
 
-            if sentry_span
-              sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
-              sentry_span.set_data(Span::DataConventions::URL, request_info[:url])
-              sentry_span.set_data(Span::DataConventions::HTTP_METHOD, request_info[:method])
-              sentry_span.set_data(Span::DataConventions::HTTP_QUERY, request_info[:query]) if request_info[:query]
-              sentry_span.set_data(Span::DataConventions::HTTP_STATUS_CODE, res.code.to_i)
-            end
+          if record_sentry_breadcrumb?
+            record_sentry_breadcrumb(request_info, response_status)
           end
-        end
-      end
 
-      private
+          if sentry_span
+            set_span_info(sentry_span, request_info, response_status)
+          end
 
-      def set_propagation_headers(req)
-        Sentry.get_trace_propagation_headers&.each { |k, v| req[k] = v }
+          res
+        end
       end
 
-      def record_sentry_breadcrumb(request_info, res)
-        return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
-
-        crumb = Sentry::Breadcrumb.new(
-          level: :info,
-          category: BREADCRUMB_CATEGORY,
-          type: :info,
-          data: {
-            status: res.code.to_i,
-            **request_info
-          }
-        )
-        Sentry.add_breadcrumb(crumb)
-      end
+      private
 
       def from_sentry_sdk?
         dsn = Sentry.configuration.dsn
@@ -82,7 +67,7 @@ module Sentry
         # IPv6 url could look like '::1/path', and that won't parse without
         # wrapping it in square brackets.
         hostname = address =~ Resolv::IPv6::Regex ? "[#{address}]" : address
-        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{hostname}#{req.path}")
+        uri = req.uri || URI.parse(URI_PARSER.escape("#{use_ssl? ? 'https' : 'http'}://#{hostname}#{req.path}"))
         url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
 
         result = { method: req.method, url: url }
@@ -94,12 +79,6 @@ module Sentry
 
         result
       end
-
-      def propagate_trace?(url, configuration)
-        url &&
-          configuration.propagate_traces &&
-          configuration.trace_propagation_targets.any? { |target| url.match?(target) }
-      end
     end
   end
 end

data/lib/sentry/profiler/helpers.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Sentry
+  class Profiler
+    module Helpers
+      def in_app?(abs_path)
+        abs_path.match?(@in_app_pattern)
+      end
+
+      # copied from stacktrace.rb since I don't want to touch existing code
+      # TODO-neel-profiler try to fetch this from stackprof once we patch
+      # the native extension
+      def compute_filename(abs_path, in_app)
+        return nil if abs_path.nil?
+
+        under_project_root = @project_root && abs_path.start_with?(@project_root)
+
+        prefix =
+          if under_project_root && in_app
+            @project_root
+          else
+            longest_load_path = $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
+
+            if under_project_root
+              longest_load_path || @project_root
+            else
+              longest_load_path
+            end
+          end
+
+        prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+      end
+
+      def split_module(name)
+        # last module plus class/instance method
+        i = name.rindex("::")
+        function = i ? name[(i + 2)..-1] : name
+        mod = i ? name[0...i] : nil
+
+        [function, mod]
+      end
+    end
+  end
+end