sentry-ruby 0.1.2 → 4.0.1

data/lib/sentry/dsn.rb

@@ -2,7 +2,10 @@ require "uri"
 
 module Sentry
   class DSN
-    attr_reader :scheme, :project_id, :public_key, :secret_key, :host, :port, :path
+    PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
+    REQUIRED_ATTRIBUTES = %w(host path public_key project_id).freeze
+
+    attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 
     def initialize(dsn_string)
       @raw_value = dsn_string
@@ -24,7 +27,7 @@ module Sentry
     end
 
     def valid?
-      %w(host path public_key project_id).all? { |k| public_send(k) }
+      REQUIRED_ATTRIBUTES.all? { |k| public_send(k) }
     end
 
     def to_s
@@ -33,7 +36,7 @@ module Sentry
 
     def server
       server = "#{scheme}://#{host}"
-      server += ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
+      server += ":#{port}" unless port == PORT_MAP[scheme]
       server += path
       server
     end

data/lib/sentry/event.rb

@@ -5,6 +5,7 @@ require 'securerandom'
 require 'sentry/interface'
 require 'sentry/backtrace'
 require 'sentry/utils/real_ip'
+require 'sentry/utils/request_id'
 
 module Sentry
   class Event
@@ -13,21 +14,19 @@ module Sentry
       release environment server_name modules
       message user tags contexts extra
       fingerprint breadcrumbs backtrace transaction
-      platform sdk
+      platform sdk type
     )
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :id, :configuration
-
-    alias event_id id
+    attr_reader :configuration, :request, :exception, :stacktrace
 
     def initialize(configuration:, message: nil)
       # this needs to go first because some setters rely on configuration
       @configuration = configuration
 
       # Set some simple default values
-      @id            = SecureRandom.uuid.delete("-")
-      @timestamp     = Time.now.utc
+      @event_id      = SecureRandom.uuid.delete("-")
+      @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
       @sdk           = Sentry.sdk_meta
 
@@ -39,9 +38,9 @@ module Sentry
       @fingerprint = []
 
       @server_name = configuration.server_name
-      @environment = configuration.current_environment
+      @environment = configuration.environment
       @release = configuration.release
-      @modules = list_gem_specs if configuration.send_modules
+      @modules = configuration.gem_specs if configuration.send_modules
 
       @message = message || ""
 
@@ -51,8 +50,8 @@ module Sentry
     class << self
       def get_log_message(event_hash)
         message = event_hash[:message] || event_hash['message']
-        message = get_message_from_exception(event_hash) if message.empty?
-        message = '<no message value>' if message.empty?
+        message = get_message_from_exception(event_hash) if message.nil? || message.empty?
+        message = '<no message value>' if message.nil? || message.empty?
         message
       end
 
@@ -68,7 +67,7 @@ module Sentry
     end
 
     def timestamp=(time)
-      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : time
+      @timestamp = time.is_a?(Time) ? time.to_f : time
     end
 
     def level=(new_level) # needed to meet the Sentry spec
@@ -76,7 +75,7 @@ module Sentry
     end
 
     def rack_env=(env)
-      unless @request || env.empty?
+      unless request || env.empty?
         @request = Sentry::RequestInterface.new.tap do |int|
           int.from_rack(env)
         end
@@ -84,18 +83,22 @@ module Sentry
         if configuration.send_default_pii && ip = calculate_real_ip_from_rack(env.dup)
           user[:ip_address] = ip
         end
+        if request_id = Utils::RequestId.read_from(env)
+          tags[:request_id] = request_id
+        end
       end
     end
 
-    def to_hash
-      data = ATTRIBUTES.each_with_object({}) do |att, memo|
-        memo[att] = public_send(att) if public_send(att)
-      end
+    def type
+      "event"
+    end
 
+    def to_hash
+      data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
-      data[:stacktrace] = @stacktrace.to_hash if @stacktrace
-      data[:request] = @request.to_hash if @request
-      data[:exception] = @exception.to_hash if @exception
+      data[:stacktrace] = stacktrace.to_hash if stacktrace
+      data[:request] = request.to_hash if request
+      data[:exception] = exception.to_hash if exception
 
       data
     end
@@ -141,9 +144,9 @@ module Sentry
         frame.in_app = line.in_app
         frame.module = line.module_name if line.module_name
 
-        if configuration[:context_lines] && frame.abs_path
+        if configuration.context_lines && frame.abs_path
           frame.pre_context, frame.context_line, frame.post_context = \
-            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration[:context_lines])
+            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration.context_lines)
         end
 
         memo << frame if frame.filename
@@ -152,6 +155,14 @@ module Sentry
 
     private
 
+    def serialize_attributes
+      self.class::ATTRIBUTES.each_with_object({}) do |att, memo|
+        if value = public_send(att)
+          memo[att] = value
+        end
+      end
+    end
+
     # When behind a proxy (or if the user is using a proxy), we can't use
     # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
     def calculate_real_ip_from_rack(env)
@@ -162,10 +173,5 @@ module Sentry
         :forwarded_for => env["HTTP_X_FORWARDED_FOR"]
       ).calculate_ip
     end
-
-    def list_gem_specs
-      # Older versions of Rubygems don't support iterating over all specs
-      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
-    end
   end
 end

data/lib/sentry/hub.rb

@@ -67,6 +67,12 @@ module Sentry
       @stack.pop
     end
 
+    def start_transaction(transaction: nil, **options)
+      transaction ||= Transaction.new(**options)
+      transaction.set_initial_sample_desicion
+      transaction
+    end
+
     def capture_exception(exception, **options, &block)
       return unless current_client
 
@@ -74,12 +80,16 @@ module Sentry
 
       return unless event
 
+      options[:hint] ||= {}
+      options[:hint] = options[:hint].merge(exception: exception)
       capture_event(event, **options, &block)
     end
 
     def capture_message(message, **options, &block)
       return unless current_client
 
+      options[:hint] ||= {}
+      options[:hint] = options[:hint].merge(message: message)
       event = current_client.event_from_message(message)
       capture_event(event, **options, &block)
     end
@@ -87,6 +97,7 @@ module Sentry
     def capture_event(event, **options, &block)
       return unless current_client
 
+      hint = options.delete(:hint)
       scope = current_scope.dup
 
       if block
@@ -97,9 +108,9 @@ module Sentry
         scope.update_from_options(**options)
       end
 
-      event = current_client.capture_event(event, scope)
+      event = current_client.capture_event(event, scope, hint)
 
-      @last_event_id = event.id
+      @last_event_id = event.event_id
       event
     end
 

data/lib/sentry/interfaces/request.rb

@@ -39,15 +39,6 @@ module Sentry
 
     private
 
-    # Request ID based on ActionDispatch::RequestId
-    def read_request_id_from(env_hash)
-      REQUEST_ID_HEADERS.each do |key|
-        request_id = env_hash[key]
-        return request_id if request_id
-      end
-      nil
-    end
-
     # See Sentry server default limits at
     # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     def read_data_from(request)
@@ -67,7 +58,7 @@ module Sentry
         begin
           key = key.to_s # rack env can contain symbols
           value = value.to_s
-          next memo['X-Request-Id'] ||= read_request_id_from(env_hash) if REQUEST_ID_HEADERS.include?(key)
+          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env_hash) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
           next unless key.upcase == key # Non-upper case stuff isn't either
 
           # Rack adds in an incorrect HTTP_VERSION key, which causes downstream

data/lib/sentry/rack.rb

@@ -2,3 +2,4 @@ require 'time'
 require 'rack'
 
 require 'sentry/rack/capture_exception'
+require 'sentry/rack/tracing'

data/lib/sentry/rack/tracing.rb

@@ -0,0 +1,39 @@
+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/rake.rb

@@ -0,0 +1,17 @@
+require "rake"
+require "rake/task"
+
+module Rake
+  class Application
+    alias orig_display_error_messsage display_error_message
+    def display_error_message(ex)
+      Sentry.capture_exception(ex) do |scope|
+        task_name = top_level_tasks.join(' ')
+        scope.set_transaction_name(task_name)
+        scope.set_tag("rake_task", task_name)
+      end
+
+      orig_display_error_messsage(ex)
+    end
+  end
+end

data/lib/sentry/scope.rb

@@ -3,7 +3,7 @@ require "etc"
 
 module Sentry
   class Scope
-    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env]
+    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span]
 
     attr_reader(*ATTRIBUTES)
 
@@ -15,20 +15,25 @@ module Sentry
       set_default_value
     end
 
-    def apply_to_event(event)
+    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.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)
+          event = processor_block.call(event, hint)
         end
       end
 
@@ -52,6 +57,7 @@ module Sentry
       copy.user = user.deep_dup
       copy.transaction_names = transaction_names.deep_dup
       copy.fingerprint = fingerprint.deep_dup
+      copy.span = span
       copy
     end
 
@@ -63,6 +69,7 @@ module Sentry
       self.user = scope.user
       self.transaction_names = scope.transaction_names
       self.fingerprint = scope.fingerprint
+      self.span = scope.span
     end
 
     def update_from_options(
@@ -86,6 +93,11 @@ module Sentry
       @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
@@ -130,6 +142,15 @@ module Sentry
       @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)
 
@@ -164,6 +185,7 @@ module Sentry
       @transaction_names = []
       @event_processors = []
       @rack_env = {}
+      @span = nil
     end
 
     class << self

data/lib/sentry/span.rb

@@ -0,0 +1,155 @@
+# 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