sentry-ruby 0.3.0 → 4.2.0

data/lib/sentry/interfaces/stacktrace.rb

@@ -1,57 +0,0 @@
-module Sentry
-  class StacktraceInterface < Interface
-    attr_accessor :frames
-
-    def to_hash
-      data = super
-      data[:frames] = data[:frames].map(&:to_hash)
-      data
-    end
-
-    # Not actually an interface, but I want to use the same style
-    class Frame < Interface
-      attr_accessor :abs_path, :context_line, :function, :in_app,
-                    :lineno, :module, :pre_context, :post_context, :vars
-
-      def initialize(project_root)
-        @project_root = project_root
-      end
-
-      def filename
-        return if abs_path.nil?
-        return @filename if instance_variable_defined?(:@filename)
-
-        prefix =
-          if under_project_root? && in_app
-            @project_root
-          elsif under_project_root?
-            longest_load_path || @project_root
-          else
-            longest_load_path
-          end
-
-        @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
-      end
-
-      def to_hash(*args)
-        data = super(*args)
-        data[:filename] = filename
-        data.delete(:vars) unless vars && !vars.empty?
-        data.delete(:pre_context) unless pre_context && !pre_context.empty?
-        data.delete(:post_context) unless post_context && !post_context.empty?
-        data.delete(:context_line) unless context_line && !context_line.empty?
-        data
-      end
-
-      private
-
-      def under_project_root?
-        @project_root && abs_path.start_with?(@project_root)
-      end
-
-      def longest_load_path
-        $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
-      end
-    end
-  end
-end

data/lib/sentry/linecache.rb

@@ -1,44 +0,0 @@
-module Sentry
-  class LineCache
-    def initialize
-      @cache = {}
-    end
-
-    # Any linecache you provide to Sentry must implement this method.
-    # Returns an Array of Strings representing the lines in the source
-    # file. The number of lines retrieved is (2 * context) + 1, the middle
-    # line should be the line requested by lineno. See specs for more information.
-    def get_file_context(filename, lineno, context)
-      return nil, nil, nil unless valid_path?(filename)
-
-      lines = Array.new(2 * context + 1) do |i|
-        getline(filename, lineno - context + i)
-      end
-      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
-    end
-
-    private
-
-    def valid_path?(path)
-      lines = getlines(path)
-      !lines.nil?
-    end
-
-    def getlines(path)
-      @cache[path] ||= begin
-        IO.readlines(path)
-                       rescue
-                         nil
-      end
-    end
-
-    def getline(path, n)
-      return nil if n < 1
-
-      lines = getlines(path)
-      return nil if lines.nil?
-
-      lines[n - 1]
-    end
-  end
-end

data/lib/sentry/logger.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'logger'
-
-module Sentry
-  class Logger < ::Logger
-    LOG_PREFIX = "** [Sentry] "
-    PROGNAME   = "sentry"
-
-    def initialize(*)
-      super
-      @level = ::Logger::INFO
-      original_formatter = ::Logger::Formatter.new
-      @default_formatter = proc do |severity, datetime, _progname, msg|
-        msg = "#{LOG_PREFIX}#{msg}"
-        original_formatter.call(severity, datetime, PROGNAME, msg)
-      end
-    end
-  end
-end

data/lib/sentry/rack/capture_exception.rb

@@ -1,45 +0,0 @@
-module Sentry
-  module Rack
-    class CaptureException
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        # this call clones the main (global) hub
-        # and assigns it to the current thread's Sentry#get_current_hub
-        # it's essential for multi-thread servers (e.g. puma)
-        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
-        # this call creates an isolated scope for every request
-        # it's essential for multi-process servers (e.g. unicorn)
-        Sentry.with_scope do |scope|
-          # there could be some breadcrumbs already stored in the top-level scope
-          # and for request information, we don't need those breadcrumbs
-          scope.clear_breadcrumbs
-          env['sentry.client'] = Sentry.get_current_client
-
-          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
-          scope.set_rack_env(env)
-
-          begin
-            response = @app.call(env)
-          rescue Sentry::Error
-            raise # Don't capture Sentry errors
-          rescue Exception => e
-            Sentry.capture_exception(e)
-            raise
-          end
-
-          exception = collect_exception(env)
-          Sentry.capture_exception(exception) if exception
-
-          response
-        end
-      end
-
-      def collect_exception(env)
-        env['rack.exception'] || env['sinatra.error']
-      end
-    end
-  end
-end

data/lib/sentry/rack/tracing.rb

@@ -1,39 +0,0 @@
-module Sentry
-  module Rack
-    class Tracing
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
-
-        if Sentry.configuration.traces_sample_rate.to_f == 0.0
-          return @app.call(env)
-        end
-
-        Sentry.with_scope do |scope|
-          scope.clear_breadcrumbs
-          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
-          span = Sentry.start_transaction(name: scope.transaction_name, op: "rack.request")
-          scope.set_span(span)
-
-          begin
-            response = @app.call(env)
-          rescue
-            finish_span(span, 500)
-            raise
-          end
-
-          finish_span(span, response[0])
-          response
-        end
-      end
-
-      def finish_span(span, status_code)
-        span.set_http_status(status_code)
-        span.finish
-      end
-    end
-  end
-end

data/lib/sentry/rack.rb

@@ -1,5 +0,0 @@
-require 'time'
-require 'rack'
-
-require 'sentry/rack/capture_exception'
-require 'sentry/rack/tracing'

data/lib/sentry/scope.rb

@@ -1,214 +0,0 @@
-require "sentry/breadcrumb_buffer"
-require "etc"
-
-module Sentry
-  class Scope
-    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
-
-      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
-      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 check_argument_type!(argument, expected_type)
-      unless argument.is_a?(expected_type)
-        raise ArgumentError, "expect the argument to be a #{expected_type}, got #{argument.class} (#{argument})"
-      end
-    end
-
-    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

@@ -1,155 +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 set_span_recorder
-      @span_recorder = SpanRecorder.new(1000)
-      @span_recorder.add(self)
-    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)
-      child_span = Span.new(options)
-      child_span.span_recorder = @span_recorder
-
-      if @span_recorder && @sampled
-        @span_recorder.add(child_span)
-      end
-
-      child_span
-    end
-
-    def with_child_span(**options, &block)
-      child_span = start_child(**options)
-
-      yield(child_span)
-
-      child_span.finish
-    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
-
-    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.rb

@@ -1,113 +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 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 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
-  end
-end