sentry-ruby 0.1.2 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cd10cdc1a28f396af641980c7440ab8fc74648a2ebe1364e81d137af7a8d832
-  data.tar.gz: d96bebca93ed6d16fc4bc1a7c6f14a53f33ebf84f4d6197ce79ee344bd2a0056
+  metadata.gz: 732989200a2cbf0a935c386cf84037d655332953ea2fef828099fbf68b756ab9
+  data.tar.gz: 4aecc66958496eede273d4cc4b2e3861e0ce7eb3cf769912a4a6675efeba693e
 SHA512:
-  metadata.gz: bacf5d66a156684b3dcf3048806ffab6b53f3172a146626a4b28e4a80d1c933a729ee813a933052a425d86d3c58ce04b8409a55ba0b3fe76c45cce3defc8a6f0
-  data.tar.gz: 756550d44dd6765e478ae2922f69c2098121c3ae290dd99345805d5690281021683146b54e999b77ed82b82330f40b5ec7e57b172a39741e4023c911c9867cb0
+  metadata.gz: 798be41100ec3c8eb09039f9432df02fd0de323427fd0d8bf6d9ced8f7b39d420e972c6006bcb4490002e32f03acfad2311b8ddab826c6927bd53b2a7316c7cb
+  data.tar.gz: 78cc7ec6d5c1a7f6603f9f2e4917b26e12ad5b13c0387a00645282acf8c910518c4132c171e2c9a8311f11e82afa3eb0454d2102bf48abd4c44d6625fd4ce4cf

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 4.0.1
+
+- Add rake integration: [1137](https://github.com/getsentry/sentry-ruby/pull/1137)
+- Make Event's interfaces accessible: [1135](https://github.com/getsentry/sentry-ruby/pull/1135)
+- ActiveSupportLogger should only record events that has a started time: [1132](https://github.com/getsentry/sentry-ruby/pull/1132)
+
+## 4.0.0
+
+- Only documents update for the official release and no API/feature changes.
+
+## 0.3.0
+
+- Major API changes: [1123](https://github.com/getsentry/sentry-ruby/pull/1123)
+- Support event hint: [1122](https://github.com/getsentry/sentry-ruby/pull/1122)
+- Add request-id tag to events: [1120](https://github.com/getsentry/sentry-ruby/pull/1120) (by @tvec)
+
+## 0.2.0
+
+- Multiple fixes and refactorings
+- Tracing support
+
+## 0.1.3
+
+Fix require reference
+
 ## 0.1.2
 
 - Fix: Fix async callback [1098](https://github.com/getsentry/sentry-ruby/pull/1098)

data/Gemfile

@@ -9,3 +9,8 @@ gem "codecov"
 
 gem "pry"
 gem "rack"
+
+gem "benchmark-ips"
+gem "benchmark_driver"
+gem "benchmark-ipsa"
+gem "benchmark-memory"

data/README.md

@@ -7,6 +7,8 @@
 
 # sentry-ruby, the Ruby Client for Sentry
 
+**The old `sentry-raven` client has entered maintenance mode and was moved to [here](https://github.com/getsentry/sentry-ruby/tree/master/sentry-raven).**
+
 ---
 
 
@@ -17,7 +19,7 @@
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=sentry-ruby&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=sentry-ruby&package-manager=bundler&version-scheme=semver)
 
 
-[Documentation](https://docs.sentry.io/clients/ruby/) | [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues) | [Forum](https://forum.sentry.io/) | IRC: irc.freenode.net, #sentry
+[Documentation](https://docs.sentry.io/platforms/ruby/) | [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues) | [Forum](https://forum.sentry.io/) | IRC: irc.freenode.net, #sentry
 
 The official Ruby-language client and integration layer for the [Sentry](https://github.com/getsentry/sentry) error reporting API.
 
@@ -26,6 +28,10 @@ The official Ruby-language client and integration layer for the [Sentry](https:/
 
 We test on Ruby 2.4, 2.5, 2.6 and 2.7 at the latest patchlevel/teeny version. We also support JRuby 9.0.
 
+## Migrate From sentry-raven
+
+If you're using `sentry-raven`, we recommend you to migrate to this new SDK. You can find the benefits of migrating and how to do it in our [migration guide](https://docs.sentry.io/platforms/ruby/migration/).
+
 ## Getting Started
 
 ### Install
@@ -70,17 +76,47 @@ Sentry.init do |config|
 end
 ```
 
+### Performance Monitoring
+
+You can activate performance monitoring by enabling traces sampling:
+
+```ruby
+Sentry.init do |config|
+  # set a uniform sample rate between 0.0 and 1.0
+  config.traces_sample_rate = 0.2
+
+  # or control sampling dynamically
+  config.traces_sampler = lambda do |sampling_context|
+    # sampling_context[:transaction_context] contains the information about the transaction
+    # sampling_context[:parent_sampled] contains the transaction's parent's sample decision
+    true # return value can be a boolean or a float between 0.0 and 1.0
+  end
+end
+```
+
+To lean more about performance monitoring, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/performance).
+
 ### Usage
 
 `sentry-ruby` has a default integration with `Rack`, so you only need to use the middleware in your application like:
 
-```
-require 'rack'
-require 'sentry'
+```ruby
+require 'sentry-ruby'
 
-use Sentry::Rack::CaptureException
+Sentry.init do |config|
+  config.dsn = 'https://examplePublicKey@o0.ingest.sentry.io/0'
+
+  # To activate performance monitoring, set one of these options.
+  # We recommend adjusting the value in production:
+  config.traces_sample_rate = 0.5
+  # or
+  config.traces_sampler = lambda do |context|
+    true
+  end
+end
 
-run theapp
+use Sentry::Rack::Tracing # this needs to be placed first
+use Sentry::Rack::CaptureException
 ```
 
 Otherwise, Sentry you can always use the capture helpers manually
@@ -148,6 +184,16 @@ end
 Sentry.capture_exception(exception) # the event will carry all those information now
 ```
 
+Or use top-level setters
+
+
+```ruby
+Sentry.set_user(id: 1, email: "test@example.com")
+Sentry.set_tags(tag_1: "foo", tag_2: "bar")
+Sentry.set_extras(order_number: 1234, tickets_count: 4)
+
+```
+
 Or build up a temporary scope for local information:
 
 ```ruby
@@ -172,7 +218,7 @@ Sentry.capture_exception(exception, tags: {foo: "bar"})
 
 ## More Information
 
-* [Documentation](https://docs.sentry.io/clients/ruby/)
+* [Documentation](https://docs.sentry.io/platforms/ruby/)
 * [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues)
 * [Forum](https://forum.sentry.io/)
 - [Discord](https://discord.gg/ez5KZN7)

data/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec).tap do |task|
+  task.rspec_opts = "--order rand"
+end
 
 task :default => :spec

data/lib/{sentry.rb → sentry-ruby.rb}

@@ -1,11 +1,25 @@
+require "forwardable"
+
 require "sentry/version"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/configuration"
 require "sentry/logger"
 require "sentry/event"
+require "sentry/transaction_event"
+require "sentry/span"
+require "sentry/transaction"
 require "sentry/hub"
 require "sentry/rack"
 
+def safely_require(lib)
+  begin
+    require lib
+  rescue LoadError
+  end
+end
+
+safely_require "sentry/rake"
+
 module Sentry
   class Error < StandardError
   end
@@ -20,7 +34,15 @@ module Sentry
     META
   end
 
+  def self.utc_now
+    Time.now.utc
+  end
+
   class << self
+    extend Forwardable
+
+    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
+
     def init(&block)
       config = Configuration.new
       yield(config)
@@ -39,8 +61,8 @@ module Sentry
       configuration.logger
     end
 
-    def breadcrumbs
-      get_current_scope.breadcrumbs
+    def add_breadcrumb(breadcrumb, &block)
+      get_current_scope.breadcrumbs.record(breadcrumb, &block)
     end
 
     def configuration
@@ -92,6 +114,10 @@ module Sentry
       get_current_hub.capture_message(message, **options, &block)
     end
 
+    def start_transaction(**options)
+      get_current_hub.start_transaction(**options)
+    end
+
     def last_event_id
       get_current_hub.last_event_id
     end

data/lib/sentry/benchmarks/benchmark_transport.rb

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

data/lib/sentry/breadcrumb.rb

@@ -2,13 +2,13 @@ module Sentry
   class Breadcrumb
     attr_accessor :category, :data, :message, :level, :timestamp, :type
 
-    def initialize
-      @category = nil
-      @data = {}
-      @level = nil
-      @message = nil
-      @timestamp = Time.now.to_i
-      @type = nil
+    def initialize(category: nil, data: nil, message: nil, timestamp: nil, level: nil, type: nil)
+      @category = category
+      @data = data || {}
+      @level = level
+      @message = message
+      @timestamp = timestamp || Sentry.utc_now.to_i
+      @type = type
     end
 
     def to_hash

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -58,17 +58,15 @@ module Sentry
         last_crumb = current_breadcrumbs.peek
         # try to avoid dupes from logger broadcasts
         if last_crumb.nil? || last_crumb.message != message
-          current_breadcrumbs.record do |crumb|
-            crumb.level = Sentry::Breadcrumb::SentryLogger::LEVELS.fetch(severity, nil)
-            crumb.category = category
-            crumb.message = message
-            crumb.type =
-              if severity >= 3
-                "error"
-              else
-                crumb.level
-              end
-          end
+          level = Sentry::Breadcrumb::SentryLogger::LEVELS.fetch(severity, nil)
+          crumb = Sentry::Breadcrumb.new(
+            level: level,
+            category: category,
+            message: message,
+            type: severity >= 3 ? "error" : level
+          )
+
+          Sentry.add_breadcrumb(crumb)
         end
       end
 
@@ -80,21 +78,7 @@ module Sentry
       end
 
       def current_breadcrumbs
-        Sentry.breadcrumbs
-      end
-    end
-    module OldBreadcrumbsSentryLogger
-      def self.included(base)
-        base.class_eval do
-          include Sentry::Breadcrumbs::SentryLogger
-          alias_method :add_without_sentry, :add
-          alias_method :add, :add_with_sentry
-        end
-      end
-
-      def add_with_sentry(*args)
-        add_breadcrumb(*args)
-        add_without_sentry(*args)
+        Sentry.get_current_scope.breadcrumbs
       end
     end
   end

data/lib/sentry/breadcrumb_buffer.rb

@@ -10,11 +10,8 @@ module Sentry
       @buffer = Array.new(size)
     end
 
-    def record(crumb = nil)
-      if block_given?
-        crumb = Breadcrumb.new if crumb.nil?
-        yield(crumb)
-      end
+    def record(crumb)
+      yield(crumb) if block_given?
       @buffer.slice!(0)
       @buffer << crumb
     end

data/lib/sentry/client.rb

@@ -20,8 +20,8 @@ module Sentry
       end
     end
 
-    def capture_event(event, scope)
-      scope.apply_to_event(event)
+    def capture_event(event, scope, hint = nil)
+      scope.apply_to_event(event, hint)
 
       if configuration.async?
         begin
@@ -30,10 +30,10 @@ module Sentry
           configuration.async.call(event.to_json_compatible)
         rescue => e
           configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
-          send_event(event)
+          send_event(event, hint)
         end
       else
-        send_event(event)
+        send_event(event, hint)
       end
 
       event
@@ -51,8 +51,20 @@ module Sentry
       Event.new(configuration: configuration, message: message)
     end
 
+    def event_from_transaction(transaction)
+      TransactionEvent.new(configuration: configuration).tap do |event|
+        event.transaction = transaction.name
+        event.contexts.merge!(trace: transaction.get_trace_context)
+        event.timestamp = transaction.timestamp
+        event.start_timestamp = transaction.start_timestamp
+
+        finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
+        event.spans = finished_spans.map(&:to_hash)
+      end
+    end
+
     def send_event(event, hint = nil)
-      return false unless configuration.sending_allowed?(event)
+      return false unless configuration.sending_allowed?
 
       event = configuration.before_send.call(event, hint) if configuration.before_send
       if event.nil?

data/lib/sentry/configuration.rb

@@ -15,6 +15,28 @@ module Sentry
     attr_reader :async
     alias async? async
 
+    # a proc/lambda that takes an array of stack traces
+    # it'll be used to silence (reduce) backtrace of the exception
+    #
+    # for example:
+    #
+    # ```ruby
+    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+    #   Rails.backtrace_cleaner.clean(backtrace)
+    # end
+    # ```
+    #
+    attr_accessor :backtrace_cleanup_callback
+
+    # Optional Proc, called before sending an event to the server/
+    # E.g.: lambda { |event| event }
+    # E.g.: lambda { |event| nil }
+    # E.g.: lambda { |event|
+    #   event[:message] = 'a'
+    #   event
+    # }
+    attr_reader :before_send
+
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
     # - :active_support_logger
@@ -24,10 +46,13 @@ module Sentry
     attr_accessor :context_lines
 
     # RACK_ENV by default.
-    attr_reader :current_environment
+    attr_reader :environment
+
+    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
+    attr_reader :dsn
 
-    # Whitelist of environments that will send notifications to Sentry. Array of Strings.
-    attr_accessor :environments
+    # Whitelist of enabled_environments that will send notifications to Sentry. Array of Strings.
+    attr_accessor :enabled_environments
 
     # Logger 'progname's to exclude from breadcrumbs
     attr_accessor :exclude_loggers
@@ -64,51 +89,36 @@ module Sentry
     # any events, and a value of 1.0 will send 100% of events.
     attr_accessor :sample_rate
 
-    # a proc/lambda that takes an array of stack traces
-    # it'll be used to silence (reduce) backtrace of the exception
-    #
-    # for example:
-    #
-    # ```ruby
-    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
-    #   Rails.backtrace_cleaner.clean(backtrace)
-    # end
-    # ```
-    #
-    attr_accessor :backtrace_cleanup_callback
-
     # Include module versions in reports - boolean.
     attr_accessor :send_modules
 
+    # When send_default_pii's value is false (default), sensitive information like
+    # - user ip
+    # - user cookie
+    # - request body
+    # will not be sent to Sentry.
     attr_accessor :send_default_pii
 
     attr_accessor :server_name
 
-    # Provide a configurable callback to determine event capture.
-    # Note that the object passed into the block will be a String (messages) or
-    # an exception.
-    # e.g. lambda { |exc_or_msg| exc_or_msg.some_attr == false }
-    attr_reader :should_capture
-
-    # Silences ready message when true.
-    attr_accessor :silence_ready
-
+    # Return a Transport::Configuration object for transport-related configurations.
     attr_reader :transport
 
-    # Optional Proc, called before sending an event to the server/
-    # E.g.: lambda { |event, hint| event }
-    # E.g.: lambda { |event, hint| nil }
-    # E.g.: lambda { |event, hint|
-    #   event[:message] = 'a'
-    #   event
-    # }
-    attr_reader :before_send
+    # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
+    attr_accessor :traces_sample_rate
 
-    # Errors object - an Array that contains error messages. See #
-    attr_reader :errors
+    # Take a Proc that controls the sample rate for every tracing event, e.g.
+    # ```
+    # lambda do |tracing_context|
+    #   # tracing_context[:transaction_context] contains the information about the transaction
+    #   # tracing_context[:parent_sampled] contains the transaction's parent's sample decision
+    #   true # return value can be a boolean or a float between 0.0 and 1.0
+    # end
+    # ```
+    attr_accessor :traces_sampler
 
-    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
-    attr_reader :dsn
+    # these are not config options
+    attr_reader :errors, :gem_specs
 
     # Most of these errors generate 4XX responses. In general, Sentry clients
     # only automatically report 5xx responses.
@@ -138,8 +148,8 @@ module Sentry
       self.async = false
       self.breadcrumbs_logger = []
       self.context_lines = 3
-      self.current_environment = current_environment_from_env
-      self.environments = []
+      self.environment = environment_from_env
+      self.enabled_environments = []
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT.dup
       self.inspect_exception_causes_for_exclusion = false
@@ -153,11 +163,12 @@ module Sentry
       self.send_default_pii = false
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
-      self.should_capture = false
 
-      @transport = Transport::Configuration.new
       self.before_send = false
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
+
+      @transport = Transport::Configuration.new
+      @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
       post_initialization_callback
     end
 
@@ -195,14 +206,6 @@ module Sentry
       @breadcrumbs_logger = logger
     end
 
-    def should_capture=(value)
-      unless value == false || value.respond_to?(:call)
-        raise ArgumentError, "should_capture must be callable (or false to disable)"
-      end
-
-      @should_capture = value
-    end
-
     def before_send=(value)
       unless value == false || value.respond_to?(:call)
         raise ArgumentError, "before_send must be callable (or false to disable)"
@@ -211,31 +214,21 @@ module Sentry
       @before_send = value
     end
 
-    # Allows config options to be read like a hash
-    #
-    # @param [Symbol] option Key for a given attribute
-    def [](option)
-      public_send(option)
+    def environment=(environment)
+      @environment = environment.to_s
     end
 
-    def current_environment=(environment)
-      @current_environment = environment.to_s
-    end
-
-    def capture_allowed?(message_or_exc = nil)
+    def sending_allowed?
       @errors = []
 
       valid? &&
-        capture_in_current_environment? &&
-        capture_allowed_by_callback?(message_or_exc) &&
+        capture_in_environment? &&
         sample_allowed?
     end
-    # If we cannot capture, we cannot send.
-    alias sending_allowed? capture_allowed?
 
     def error_messages
-      @errors = [errors[0]] + errors[1..-1].map(&:downcase) # fix case of all but first
-      errors.join(", ")
+      @errors = [@errors[0]] + @errors[1..-1].map(&:downcase) # fix case of all but first
+      @errors.join(", ")
     end
 
     def project_root=(root_dir)
@@ -256,7 +249,11 @@ module Sentry
     end
 
     def enabled_in_current_env?
-      environments.empty? || environments.include?(current_environment)
+      enabled_environments.empty? || enabled_environments.include?(environment)
+    end
+
+    def tracing_enabled?
+      !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
     end
 
     private
@@ -279,13 +276,17 @@ module Sentry
     end
 
     def excluded_exception?(incoming_exception)
-      excluded_exceptions.any? do |excluded_exception|
-        matches_exception?(get_exception_class(excluded_exception), incoming_exception)
+      excluded_exception_classes.any? do |excluded_exception|
+        matches_exception?(excluded_exception, incoming_exception)
       end
     end
 
+    def excluded_exception_classes
+      @excluded_exception_classes ||= excluded_exceptions.map { |e| get_exception_class(e) }
+    end
+
     def get_exception_class(x)
-      x.is_a?(Module) ? x : qualified_const_get(x)
+      x.is_a?(Module) ? x : safe_const_get(x)
     end
 
     def matches_exception?(excluded_exception_class, incoming_exception)
@@ -296,14 +297,9 @@ module Sentry
       end
     end
 
-    # In Ruby <2.0 const_get can't lookup "SomeModule::SomeClass" in one go
-    def qualified_const_get(x)
-      x = x.to_s
-      if !x.match(/::/)
-        Object.const_get(x)
-      else
-        x.split(MODULE_SEPARATOR).reject(&:empty?).inject(Object) { |a, e| a.const_get(e) }
-      end
+    def safe_const_get(x)
+      x = x.to_s unless x.is_a?(String)
+      Object.const_get(x)
     rescue NameError # There's no way to safely ask if a constant exist for an unknown string
       nil
     end
@@ -339,17 +335,10 @@ module Sentry
       ENV['SENTRY_RELEASE']
     end
 
-    def capture_in_current_environment?
+    def capture_in_environment?
       return true if enabled_in_current_env?
 
-      @errors << "Not configured to send/capture in environment '#{current_environment}'"
-      false
-    end
-
-    def capture_allowed_by_callback?(message_or_exc)
-      return true if !should_capture || message_or_exc.nil? || should_capture.call(message_or_exc)
-
-      @errors << "should_capture returned false"
+      @errors << "Not configured to send/capture in environment '#{environment}'"
       false
     end
 
@@ -380,7 +369,7 @@ module Sentry
         Socket.gethostbyname(hostname).first rescue server_name
     end
 
-    def current_environment_from_env
+    def environment_from_env
       ENV['SENTRY_CURRENT_ENV'] || ENV['SENTRY_ENVIRONMENT'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
     end