sentry-ruby 4.1.0 → 4.1.5.pre.beta.0

data/lib/sentry/span.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-require "securerandom"
-
-module Sentry
-  class Span
-    STATUS_MAP = {
-      400 => "invalid_argument",
-      401 => "unauthenticated",
-      403 => "permission_denied",
-      404 => "not_found",
-      409 => "already_exists",
-      429 => "resource_exhausted",
-      499 => "cancelled",
-      500 => "internal_error",
-      501 => "unimplemented",
-      503 => "unavailable",
-      504 => "deadline_exceeded"
-    }
-
-
-    attr_reader :trace_id, :span_id, :parent_span_id, :sampled, :start_timestamp, :timestamp, :description, :op, :status, :tags, :data
-    attr_accessor :span_recorder
-
-    def initialize(description: nil, op: nil, status: nil, trace_id: nil, parent_span_id: nil, sampled: nil, start_timestamp: nil, timestamp: nil)
-      @trace_id = trace_id || SecureRandom.uuid.delete("-")
-      @span_id = SecureRandom.hex(8)
-      @parent_span_id = parent_span_id
-      @sampled = sampled
-      @start_timestamp = start_timestamp || Sentry.utc_now.to_f
-      @timestamp = timestamp
-      @description = description
-      @op = op
-      @status = status
-      @data = {}
-      @tags = {}
-    end
-
-    def finish
-      # already finished
-      return if @timestamp
-
-      @timestamp = Sentry.utc_now.to_f
-      self
-    end
-
-    def to_sentry_trace
-      sampled_flag = ""
-      sampled_flag = @sampled ? 1 : 0 unless @sampled.nil?
-
-      "#{@trace_id}-#{@span_id}-#{sampled_flag}"
-    end
-
-    def to_hash
-      {
-        trace_id: @trace_id,
-        span_id: @span_id,
-        parent_span_id: @parent_span_id,
-        start_timestamp: @start_timestamp,
-        timestamp: @timestamp,
-        description: @description,
-        op: @op,
-        status: @status,
-        tags: @tags,
-        data: @data
-      }
-    end
-
-    def get_trace_context
-      {
-        trace_id: @trace_id,
-        span_id: @span_id,
-        description: @description,
-        op: @op,
-        status: @status
-      }
-    end
-
-    def start_child(**options)
-      options = options.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
-      Span.new(options)
-    end
-
-    def with_child_span(**options, &block)
-      child_span = start_child(**options)
-
-      yield(child_span)
-
-      child_span.finish
-    end
-
-    def deep_dup
-      dup
-    end
-
-    def set_op(op)
-      @op = op
-    end
-
-    def set_description(description)
-      @description = description
-    end
-
-    def set_status(status)
-      @status = status
-    end
-
-    def set_timestamp(timestamp)
-      @timestamp = timestamp
-    end
-
-    def set_http_status(status_code)
-      status_code = status_code.to_i
-      set_data("status_code", status_code)
-
-      status =
-        if status_code >= 200 && status_code < 299
-          "ok"
-        else
-          STATUS_MAP[status_code]
-        end
-      set_status(status)
-    end
-
-    def set_data(key, value)
-      @data[key] = value
-    end
-
-    def set_tag(key, value)
-      @tags[key] = value
-    end
-  end
-end

data/lib/sentry/transaction.rb

@@ -1,157 +0,0 @@
-module Sentry
-  class Transaction < Span
-    SENTRY_TRACE_REGEXP = Regexp.new(
-      "^[ \t]*" +  # whitespace
-      "([0-9a-f]{32})?" +  # trace_id
-      "-?([0-9a-f]{16})?" +  # span_id
-      "-?([01])?" +  # sampled
-      "[ \t]*$"  # whitespace
-    )
-    UNLABELD_NAME = "<unlabeled transaction>".freeze
-    MESSAGE_PREFIX = "[Tracing]"
-
-    attr_reader :name, :parent_sampled
-
-    def initialize(name: nil, parent_sampled: nil, **options)
-      super(**options)
-
-      @name = name
-      @parent_sampled = parent_sampled
-      set_span_recorder
-    end
-
-    def set_span_recorder
-      @span_recorder = SpanRecorder.new(1000)
-      @span_recorder.add(self)
-    end
-
-    def self.from_sentry_trace(sentry_trace, **options)
-      return unless sentry_trace
-
-      match = SENTRY_TRACE_REGEXP.match(sentry_trace)
-      trace_id, parent_span_id, sampled_flag = match[1..3]
-
-      sampled = sampled_flag != "0"
-
-      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: sampled, **options)
-    end
-
-    def to_hash
-      hash = super
-      hash.merge!(name: @name, sampled: @sampled, parent_sampled: @parent_sampled)
-      hash
-    end
-
-    def start_child(**options)
-      child_span = super
-      child_span.span_recorder = @span_recorder
-
-      if @sampled
-        @span_recorder.add(child_span)
-      end
-
-      child_span
-    end
-
-    def deep_dup
-      copy = super
-      copy.set_span_recorder
-
-      @span_recorder.spans.each do |span|
-        # span_recorder's first span is the current span, which should not be added to the copy's spans
-        next if span == self
-        copy.span_recorder.add(span.dup)
-      end
-
-      copy
-    end
-
-    def set_initial_sample_desicion(sampling_context = {})
-      unless Sentry.configuration.tracing_enabled?
-        @sampled = false
-        return
-      end
-
-      return unless @sampled.nil?
-
-      transaction_description = generate_transaction_description
-
-      logger = Sentry.configuration.logger
-      sample_rate = Sentry.configuration.traces_sample_rate
-      traces_sampler = Sentry.configuration.traces_sampler
-
-      if traces_sampler.is_a?(Proc)
-        sampling_context = sampling_context.merge(
-          parent_sampled: @parent_sampled,
-          transaction_context: self.to_hash
-        )
-
-        sample_rate = traces_sampler.call(sampling_context)
-      end
-
-      unless [true, false].include?(sample_rate) || (sample_rate.is_a?(Float) && sample_rate >= 0.0 && sample_rate <= 1.0)
-        @sampled = false
-        logger.warn("#{MESSAGE_PREFIX} Discarding #{transaction_description} because of invalid sample_rate: #{sample_rate}")
-        return
-      end
-
-      if sample_rate == 0.0 || sample_rate == false
-        @sampled = false
-        logger.debug("#{MESSAGE_PREFIX} Discarding #{transaction_description} because traces_sampler returned 0 or false")
-        return
-      end
-
-      if sample_rate == true
-        @sampled = true
-      else
-        @sampled = Random.rand < sample_rate
-      end
-
-      if @sampled
-        logger.debug("#{MESSAGE_PREFIX} Starting #{transaction_description}")
-      else
-        logger.debug(
-          "#{MESSAGE_PREFIX} Discarding #{transaction_description} because it's not included in the random sample (sampling rate = #{sample_rate})"
-        )
-      end
-    end
-
-    def finish(hub: nil)
-      super() # Span#finish doesn't take arguments
-
-      if @name.nil?
-        @name = UNLABELD_NAME
-      end
-
-      return unless @sampled
-
-      hub ||= Sentry.get_current_hub
-      event = hub.current_client.event_from_transaction(self)
-      hub.capture_event(event)
-    end
-
-    private
-
-    def generate_transaction_description
-      result = op.nil? ? "" : "<#{@op}> "
-      result += "transaction"
-      result += " <#{@name}>" if @name
-      result
-    end
-
-    class SpanRecorder
-      attr_reader :max_length, :spans
-
-      def initialize(max_length)
-        @max_length = max_length
-        @spans = []
-      end
-
-      def add(span)
-        if @spans.count < @max_length
-          @spans << span
-        end
-      end
-    end
-  end
-end

data/lib/sentry/transaction_event.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Sentry
-  class TransactionEvent < Event
-    ATTRIBUTES = %i(
-      event_id level timestamp start_timestamp
-      release environment server_name modules
-      user tags contexts extra
-      transaction platform sdk type
-    )
-
-    attr_accessor(*ATTRIBUTES)
-    attr_accessor :spans
-
-    def start_timestamp=(time)
-      @start_timestamp = time.is_a?(Time) ? time.to_f : time
-    end
-
-    def type
-      "transaction"
-    end
-
-    def to_hash
-      data = super
-      data[:spans] = @spans.map(&:to_hash) if @spans
-      data
-    end
-  end
-end

data/lib/sentry/transport.rb

@@ -1,87 +0,0 @@
-require "json"
-require "base64"
-
-module Sentry
-  class Transport
-    PROTOCOL_VERSION = '5'
-    USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
-
-    attr_accessor :configuration
-
-    def initialize(configuration)
-      @configuration = configuration
-      @transport_configuration = configuration.transport
-      @dsn = configuration.dsn
-    end
-
-    def send_data(data, options = {})
-      raise NotImplementedError
-    end
-
-    def send_event(event)
-      unless configuration.sending_allowed?
-        configuration.logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
-        return
-      end
-
-      encoded_data = prepare_encoded_event(event)
-
-      return nil unless encoded_data
-
-      send_data(encoded_data)
-
-      event
-    rescue => e
-      failed_for_exception(e, event)
-      nil
-    end
-
-    def generate_auth_header
-      now = Sentry.utc_now.to_i
-      fields = {
-        'sentry_version' => PROTOCOL_VERSION,
-        'sentry_client' => USER_AGENT,
-        'sentry_timestamp' => now,
-        'sentry_key' => @dsn.public_key
-      }
-      fields['sentry_secret'] = @dsn.secret_key if @dsn.secret_key
-      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
-    end
-
-    def encode(event_hash)
-      event_id = event_hash[:event_id] || event_hash['event_id']
-      event_type = event_hash[:type] || event_hash['type']
-
-      envelope = <<~ENVELOPE
-        {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{Sentry.utc_now.iso8601}"}
-        {"type":"#{event_type}","content_type":"application/json"}
-        #{JSON.generate(event_hash)}
-      ENVELOPE
-
-      envelope
-    end
-
-    private
-
-    def prepare_encoded_event(event)
-      # Convert to hash
-      event_hash = event.to_hash
-
-      event_id = event_hash[:event_id] || event_hash['event_id']
-      configuration.logger.info(LOGGER_PROGNAME) { "Sending event #{event_id} to Sentry" }
-      encode(event_hash)
-    end
-
-    def failed_for_exception(e, event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}" }
-      log_not_sending(event)
-    end
-
-    def log_not_sending(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event. Unreported Event: #{Event.get_log_message(event.to_hash)}" }
-    end
-  end
-end
-
-require "sentry/transport/dummy_transport"
-require "sentry/transport/http_transport"

data/lib/sentry/transport/configuration.rb

@@ -1,21 +0,0 @@
-module Sentry
-  class Transport
-    class Configuration
-      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder, :transport_class
-
-      def initialize
-        @ssl_verification = true
-        @open_timeout = 1
-        @timeout = 2
-      end
-
-      def transport_class=(klass)
-        unless klass.is_a?(Class)
-          raise Sentry::Error.new("config.transport.transport_class must a class. got: #{klass.class}")
-        end
-
-        @transport_class = klass
-      end
-    end
-  end
-end

data/lib/sentry/transport/dummy_transport.rb

@@ -1,14 +0,0 @@
-module Sentry
-  class DummyTransport < Transport
-    attr_accessor :events
-
-    def initialize(*)
-      super
-      @events = []
-    end
-
-    def send_event(event)
-      @events << event
-    end
-  end
-end

data/lib/sentry/transport/http_transport.rb

@@ -1,62 +0,0 @@
-require 'faraday'
-
-module Sentry
-  class HTTPTransport < Transport
-    CONTENT_TYPE = 'application/json'
-    attr_reader :conn, :adapter
-
-    def initialize(*args)
-      super
-      @adapter = @transport_configuration.http_adapter || Faraday.default_adapter
-      @conn = set_conn
-      @endpoint = @dsn.envelope_endpoint
-    end
-
-    def send_data(data)
-      conn.post @endpoint do |req|
-        req.headers['Content-Type'] = CONTENT_TYPE
-        req.headers['X-Sentry-Auth'] = generate_auth_header
-        req.body = data
-      end
-    rescue Faraday::Error => e
-      error_info = e.message
-
-      if e.response
-        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']
-      end
-
-      raise Sentry::Error, error_info
-    end
-
-    private
-
-    def set_conn
-      server = @dsn.server
-
-      configuration.logger.debug(LOGGER_PROGNAME) { "Sentry HTTP Transport connecting to #{server}" }
-
-      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
-
-    # 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)
-      end
-    end
-
-    def ssl_configuration
-      (@transport_configuration.ssl || {}).merge(
-        :verify => @transport_configuration.ssl_verification,
-        :ca_file => @transport_configuration.ssl_ca_file
-      )
-    end
-  end
-end