sentry-ruby-core 4.1.5.pre.beta.0

data/lib/sentry/scope.rb

@@ -0,0 +1,210 @@
+require "sentry/breadcrumb_buffer"
+require "etc"
+
+module Sentry
+  class Scope
+    include ArgumentCheckingHelper
+
+    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span]
+
+    attr_reader(*ATTRIBUTES)
+
+    def initialize
+      set_default_value
+    end
+
+    def clear
+      set_default_value
+    end
+
+    def apply_to_event(event, hint = nil)
+      event.tags = tags.merge(event.tags)
+      event.user = user.merge(event.user)
+      event.extra = extra.merge(event.extra)
+      event.contexts = contexts.merge(event.contexts)
+
+      if span
+        event.contexts[:trace] = span.get_trace_context
+      end
+
+      event.fingerprint = fingerprint
+      event.level = level
+      event.transaction = transaction_names.last
+      event.breadcrumbs = breadcrumbs
+      event.rack_env = rack_env if rack_env
+
+      unless @event_processors.empty?
+        @event_processors.each do |processor_block|
+          event = processor_block.call(event, hint)
+        end
+      end
+
+      event
+    end
+
+    def add_breadcrumb(breadcrumb)
+      breadcrumbs.record(breadcrumb)
+    end
+
+    def clear_breadcrumbs
+      @breadcrumbs = BreadcrumbBuffer.new
+    end
+
+    def dup
+      copy = super
+      copy.breadcrumbs = breadcrumbs.dup
+      copy.contexts = contexts.deep_dup
+      copy.extra = extra.deep_dup
+      copy.tags = tags.deep_dup
+      copy.user = user.deep_dup
+      copy.transaction_names = transaction_names.deep_dup
+      copy.fingerprint = fingerprint.deep_dup
+      copy.span = span.deep_dup
+      copy
+    end
+
+    def update_from_scope(scope)
+      self.breadcrumbs = scope.breadcrumbs
+      self.contexts = scope.contexts
+      self.extra = scope.extra
+      self.tags = scope.tags
+      self.user = scope.user
+      self.transaction_names = scope.transaction_names
+      self.fingerprint = scope.fingerprint
+      self.span = scope.span
+    end
+
+    def update_from_options(
+      contexts: nil,
+      extra: nil,
+      tags: nil,
+      user: nil,
+      level: nil,
+      fingerprint: nil
+    )
+      self.contexts.merge!(contexts) if contexts
+      self.extra.merge!(extra) if extra
+      self.tags.merge!(tags) if tags
+      self.user = user if user
+      self.level = level if level
+      self.fingerprint = fingerprint if fingerprint
+    end
+
+    def set_rack_env(env)
+      env = env || {}
+      @rack_env = env
+    end
+
+    def set_span(span)
+      check_argument_type!(span, Span)
+      @span = span
+    end
+
+    def set_user(user_hash)
+      check_argument_type!(user_hash, Hash)
+      @user = user_hash
+    end
+
+    def set_extras(extras_hash)
+      check_argument_type!(extras_hash, Hash)
+      @extra.merge!(extras_hash)
+    end
+
+    def set_extra(key, value)
+      @extra.merge!(key => value)
+    end
+
+    def set_tags(tags_hash)
+      check_argument_type!(tags_hash, Hash)
+      @tags.merge!(tags_hash)
+    end
+
+    def set_tag(key, value)
+      @tags.merge!(key => value)
+    end
+
+    def set_contexts(contexts_hash)
+      check_argument_type!(contexts_hash, Hash)
+      @contexts = contexts_hash
+    end
+
+    def set_context(key, value)
+      @contexts.merge!(key => value)
+    end
+
+    def set_level(level)
+      @level = level
+    end
+
+    def set_transaction_name(transaction_name)
+      @transaction_names << transaction_name
+    end
+
+    def transaction_name
+      @transaction_names.last
+    end
+
+    def get_transaction
+      # transaction will always be the first in the span_recorder
+      span.span_recorder.spans.first if span
+    end
+
+    def get_span
+      span
+    end
+
+    def set_fingerprint(fingerprint)
+      check_argument_type!(fingerprint, Array)
+
+      @fingerprint = fingerprint
+    end
+
+    def add_event_processor(&block)
+      @event_processors << block
+    end
+
+    protected
+
+    # for duplicating scopes internally
+    attr_writer(*ATTRIBUTES)
+
+    private
+
+    def set_default_value
+      @breadcrumbs = BreadcrumbBuffer.new
+      @contexts = { :os => self.class.os_context, :runtime => self.class.runtime_context }
+      @extra = {}
+      @tags = {}
+      @user = {}
+      @level = :error
+      @fingerprint = []
+      @transaction_names = []
+      @event_processors = []
+      @rack_env = {}
+      @span = nil
+    end
+
+    class << self
+      def os_context
+        @os_context ||=
+          begin
+            uname = Etc.uname
+            {
+              name: uname[:sysname] || RbConfig::CONFIG["host_os"],
+              version: uname[:version],
+              build: uname[:release],
+              kernel_version: uname[:version]
+            }
+          end
+      end
+
+      def runtime_context
+        @runtime_context ||= {
+          name: RbConfig::CONFIG["ruby_install_name"],
+          version: RUBY_DESCRIPTION || Sentry.sys_command("ruby -v")
+        }
+      end
+    end
+
+  end
+end

data/lib/sentry/span.rb

@@ -0,0 +1,133 @@
+# 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,
+        parent_span_id: @parent_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

@@ -0,0 +1,157 @@
+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 || @parent_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